dejima

KO | EN

gitlite — search

#llm #command-line #web #devops #machine-learning #csharp #sql #awesome #html #java

(★ 9)

No description available.

파일 탐색기

ZIP 다운로드

- - ci.yml
  - metrics.yml
  - nightly-live.yml
  - nightly.yml
  - release.yml
  - sdk-publish.yml
  - sdk.yml
- - 01-fleet-dashboard.tape
  - 02-secrets.tape
  - 03-file-to-agent.tape
  - 04-first-island.tape
  - README.md
- apple-touch-icon.png
- architecture.png
- architecture.svg
- brand-island.png
- brand-island.svg
- dejima-screenshot1.png
- favicon-256.png
- favicon.ico
- logo-transparent.png
- logo.png
- og-audit-agent.png
- og-audit-agent.svg
- og-build-notifier.png
- og-build-notifier.svg
- og-card.png
- og-card.svg
- og-cloud-vm.png
- og-cloud-vm.svg
- og-linux-server.png
- og-linux-server.svg
- og-local.png
- og-local.svg
- og-mac-mini.png
- og-mac-mini.svg
- og-scope-folder.png
- og-scope-folder.svg
- og-tmux-ssh.png
- og-tmux-ssh.svg
- og-uc-private-files.png
- og-uc-private-files.svg
- og-uc-team-host.png
- og-uc-team-host.svg
- og-vs-cma.png
- og-vs-cma.svg
- og-vs-coder.png
- og-vs-coder.svg
- og-vs-daytona.png
- og-vs-daytona.svg
- og-vs-e2b.png
- og-vs-e2b.svg
- og-vs-rivet.png
- og-vs-rivet.svg
- tmux-vs-dejima.png
- tmux-vs-dejima.svg
- - activity.go
  - adopt.go
  - adopt_test.go
  - agent_display_test.go
  - agent_error_lines.go
  - agent_error_lines_test.go
  - agent_open.go
  - agent_open_dashboard_test.go
  - agent_open_diag_test.go
  - agent_open_gateway_test.go
  - agent_open_keepalive_test.go
  - agent_open_knownhosts_test.go
  - agent_open_preflight_test.go
  - altscreen.go
  - altscreen_test.go
  - approvals_watch_test.go
  - attach_file.go
  - attach_file_test.go
  - audit.go
  - auth.go
  - background_join_test.go
  - buildtail.go
  - buildtail_test.go
  - capability.go
  - cli_invocation_test.go
  - cli_secrets_isolation_test.go
  - cli_table_more_test.go
  - cli_table_test.go
  - clientterm.go
  - clientterm_test.go
  - clipboard.go
  - clipboard_test.go
  - clone_hint_test.go
  - clonehint_test.go
  - cmd_paths_test.go
  - confirm_default_test.go
  - conmode_other.go
  - conmode_test.go
  - conmode_windows.go
  - connect_pick_test.go
  - connect_picker_test.go
  - coverage_gate_test.go
  - cp_dest_test.go
  - cp_recursive.go
  - cp_recursive_test.go
  - daemon_update_verify_test.go
  - daemonhelp.go
  - daemonhelp_test.go
  - daemonhelp_wsl_test.go
  - docker_hint.go
  - docker_hint_test.go
  - doctor.go
  - doctor_checks.go
  - doctor_checks_test.go
  - doctor_docker_test.go
  - doctor_egress.go
  - doctor_egress_test.go
  - doctor_owner_other.go
  - doctor_owner_unix.go
  - doctor_reaper_test.go
  - doctor_remote_docker_test.go
  - doctor_socket_check_test.go
  - doctor_terminal.go
  - doctor_terminal_test.go
  - doctor_tmuxsize.go
  - doctor_tmuxsize_test.go
  - doctor_unattended.go
  - doctor_unattended_test.go
  - durability_test.go
  - egress.go
  - egress_test.go
  - eject.go
  - eject_test.go
  - empty_list_test.go
  - error_guidance_test.go
  - escseq.go
  - escseq_test.go
  - feedback.go
  - feedback_test.go
  - gateway_forward.go
  - gateway_tunnel.go
  - gateway_tunnel_test.go
  - github.go
  - github_host_credential.go
  - github_host_credential_test.go
  - github_identity.go
  - github_identity_test.go
  - github_test.go
  - github_token_fallback.go
  - github_token_fallback_test.go
  - github_usage_test.go
  - handoff_test.go
  - home.go
  - home_no_repo_test.go
  - image.go
  - install_channels_test.go
  - join_test.go
  - keybinding_audit_test.go
  - keylog.go
  - link.go
  - local.go
  - local_cli_guard_test.go
  - local_cli_test.go
  - local_install.go
  - local_test.go
  - main.go
  - main_test_setup_test.go
  - mcp.go
  - msg.go
  - observed.go
  - observed_cli_test.go
  - onboard.go
  - onboard_choice_src_test.go
  - onboard_choice_test.go
  - onboard_confirm_shape_test.go
  - onboard_firstrun_test.go
  - onboard_health_test.go
  - onboard_join_test.go
  - onboard_newhost_test.go
  - ownership_test.go
  - paste.go
  - paste_confirm.go
  - paste_confirm_test.go
  - paste_drop_test.go
  - paste_intercept.go
  - paste_intercept_test.go
  - paste_test.go
  - pin_test.go
  - policy.go
  - policy_test.go
  - port.go
  - portint_test.go
  - profile.go
  - profile_test.go
  - prompt_output_test.go
  - provenance.go
  - provenance_test.go
  - provider.go
  - provision.go
  - provision_confirm_test.go
  - provision_hostprep_test.go
  - provision_incomplete_test.go
  - provision_manual_test.go
  - provision_test.go
  - reconnect_test.go
  - release_blurb_test.go
  - remedy_commands_test.go
  - resize_unix.go
  - resize_windows.go
  - schedule_test.go
  - secret.go
  - secret_gh_precedence_test.go
  - secret_test.go
  - service_egress_flag_test.go
  - session_exit_test.go
  - session_reconnect_test.go
  - session_summon_test.go
  - session_title_test.go
  - settings_terminal_test.go
  - size.go
  - size_test.go
  - spawn.go
  - spawn_test.go
  - ssh.go
  - ssh_enroll_test.go
  - ssh_setup_addr_test.go
  - ssh_setup_steps.go
  - ssh_setup_steps_test.go
  - ssh_test.go
  - sudo.go
  - sudo_test.go
  - tailscale.go
  - tailscale_test.go
  - term.go
  - term_test.go
  - terminal.go
  - terminal_test.go
  - tips.go
  - tips_test.go
  - title_test.go
  - token.go
  - tui.go
  - tui_agent_removal_test.go
  - tui_agentname_test.go
  - tui_agentpick.go
  - tui_agentpick_key_test.go
  - tui_agentpick_test.go
  - tui_aggregate.go
  - tui_aggregate_test.go
  - tui_align_test.go
  - tui_approvals.go
  - tui_approvals_test.go
  - tui_audit.go
  - tui_authgap_test.go
  - tui_autoseed.go
  - tui_autoseed_test.go
  - tui_band_test.go
  - tui_confirm_test.go
  - tui_create.go
  - tui_create_from_dir_test.go
  - tui_create_gate_test.go
  - tui_create_ghgate_test.go
  - tui_create_key_test.go
  - tui_create_multiagent_test.go
  - tui_create_newrepo_test.go
  - tui_create_no_repo_test.go
  - tui_create_open_test.go
  - tui_create_preflight.go
  - tui_create_preflight_test.go
  - tui_create_root_empty_test.go
  - tui_create_test.go
  - tui_demo.go
  - tui_demo_test.go
  - tui_firstrun_creds_test.go
  - tui_firstrun_style_test.go
  - tui_focus_cursor_test.go
  - tui_gate_strength_test.go
  - tui_gateway_test.go
  - tui_github.go
  - tui_github_device.go
  - tui_github_device_test.go
  - tui_github_test.go
  - tui_glyph_test.go
  - tui_grants.go
  - tui_grants_coverage_test.go
  - tui_grants_hostgh_test.go
  - tui_grants_test.go
  - tui_group_test.go
  - tui_header_local_test.go
  - tui_header_switch_test.go
  - tui_help_sections_test.go
  - tui_help_viewport_test.go
  - tui_help_width_test.go
  - tui_identity.go
  - tui_identity_test.go
  - tui_image_rebuild_test.go
  - tui_import.go
  - tui_import_test.go
  - tui_island_shell_test.go
  - tui_local_actions_test.go
  - tui_localmodels.go
  - tui_localmodels_test.go
  - tui_model.go
  - tui_model_preselect_test.go
  - tui_model_save_test.go
  - tui_namecol.go
  - tui_namecol_test.go
  - tui_names_test.go
  - tui_observed.go
  - tui_observed_test.go
  - tui_owner_lens_test.go
  - tui_paste_input_test.go
  - tui_providers.go
  - tui_providers_test.go
  - tui_rename_test.go
  - tui_restart.go
  - tui_restart_test.go
  - tui_scope.go
  - tui_scope_test.go
  - tui_secrets.go
  - tui_secrets_test.go
  - tui_setup.go
  - tui_setup_readiness_test.go
  - tui_setup_test.go
  - tui_spawngrant.go
  - tui_spawngrant_test.go
  - tui_staleconn_test.go
  - tui_subagent_test.go
  - tui_switch.go
  - tui_switch_test.go
  - tui_team.go
  - tui_team_test.go
  - tui_teatest_more_test.go
  - tui_teatest_test.go
  - tui_test.go
  - tui_tips.go
  - tui_tips_test.go
  - tui_update_check_test.go
  - tui_update_verify_test.go
  - tui_usage_test.go
  - tui_window.go
  - tui_window_focus_test.go
  - tui_window_notest_test.go
  - tui_window_test.go
  - tui_winspawn_test.go
  - tui_wsl_diagnosis.go
  - uninstall.go
  - uninstall_client.go
  - uninstall_client_test.go
  - uninstall_degraded_test.go
  - uninstall_no_repo_test.go
  - uninstall_preflight.go
  - uninstall_preflight_test.go
  - uninstall_test.go
  - uninstall_wording_test.go
  - update.go
  - update_daemon_test.go
  - update_gate_test.go
  - version_cmd_test.go
  - voice.go
  - voice_device_test.go
  - voice_test.go
  - wsl.go
  - wsl_durability.go
  - wsl_durability_test.go
  - wsl_offline_advice_test.go
  - wsl_release_install_test.go
  - wsl_shell_test.go
  - wsl_socat_test.go
  - wsl_test.go
  - wslconf.go
  - wslconf_test.go
  - wslservice.go
  - wslservice_test.go
- - bind_name_test.go
  - hostinternal.go
  - hostinternal_test.go
  - main.go
  - main_test.go
  - tailnet_retry_test.go
- claude-managed-agents-vs-dejima.html
- coder-vs-dejima.html
- daytona-vs-dejima.html
- e2b-vs-dejima.html
- index.html
- rivet-vs-dejima.html
- index.html
- - multi-tenant-ownership.md
- - 0.5-hardening.md
  - 0.5-onboarding.md
  - 0.5-sdk-publish.md
  - 0.6-completeness.md
  - lane-0-verify-harness.md
  - lane-1-audit.md
  - lane-2-team-auth.md
  - lane-3-mcp.md
  - lane-4-sdk.md
  - lane-5-inter-island.md
  - lane-5-phase-3.5-wake.md
  - lane-6-phase-b.md
  - lane-6-phase-c.md
  - lane-6-test-harness.md
  - lane-skew-detection.md
  - lane-visual-identity.md
  - README.md
- - clean-mac-launch-gate.md
  - inter-island-wave.md
  - release-acceptance.md
  - uninstall-keep-islands-readopt.md
  - v0.6.1-tui-verify.md
  - v0.6.9-verify.md
  - verify-v0.7.1.md
  - verify-v0.8.65.md
  - verify-v0.8.md
- - invite-format-spec.md
- - automated-test-harness.md
  - coverage-gate.md
  - dejimaqa-runner-setup.md
  - full-suite-design.md
  - guards-need-controls.md
  - lifecycle-not-value.md
  - readings-go-stale.md
  - test-coverage-matrix.md
- action-gate-spec.md
- action-gate-tui-client.md
- agent-adapters.md
- agent-adoption.md
- ambient-agents-design.md
- audit.md
- capability-broker-spec.md
- capability-brokering.md
- custom-agents.md
- distribution.md
- drift-checker-design.md
- exit-ramp.md
- folder-import.md
- framework-backends.md
- gateway-proxy.md
- github-identities.md
- harness-peer-isolation.md
- host-provisioning-plan.md
- host-terminals.md
- inter-island-exchange-spec.md
- intra-island-coordination-spec.md
- island-pid1-unification.md
- launch-checklist.md
- local-models.md
- mac-mini-host-setup.md
- managed-island-files.md
- mcp-broker-spec.md
- metrics-install-totals.md
- multi-agent-impl-plan.md
- multi-agent-spec.md
- npm-publishing-setup.md
- paste-bridge.md
- port-island-spec.md
- positioning.md
- README.md
- release-notarization.md
- roadmap.md
- runbook-openclaw-home-island.md
- scheduled-wake-design.md
- scheduled-wake-spec.md
- secrets-manager-spec.md
- secrets-restart.md
- secure-island-routing.md
- security-boundary.md
- self-update.md
- setup-failure-audit.md
- tmux-passthrough.md
- tui-recording-runbook.md
- v1-milestones.md
- v1-spec.md
- watch-view.md
- windows-native-daemon.md
- workspace-source.md
- wsl-windows-postmortem.md
- audit-agent-actions.html
- build-agent-notifier.html
- cloud-vm-agent-server.html
- index.html
- linux-server-agent-server.html
- local-agents.html
- mac-mini-agent-server.html
- scope-agent-to-one-folder.html
- tmux-ssh-agents.html
- dejima.rb
- Dockerfile
- island-primer.md
- load-secrets.sh
- start.sh
- tmux.conf
- write-primer.sh
- - agentcreds.go
  - agentcreds_test.go
- - access.go
  - access_test.go
  - activity.go
  - activity_test.go
  - addagent_budget_test.go
  - admin_update.go
  - admin_update_test.go
  - agent_binary.go
  - agent_binary_test.go
  - agent_label_uniqueness_test.go
  - agent_launch_test.go
  - agent_removal_guard_test.go
  - agent_update.go
  - agent_update_test.go
  - agentnames_test.go
  - aggregate_test.go
  - attach_race_test.go
  - attach_size_test.go
  - audit.go
  - audit_test.go
  - b64.go
  - background_join_test.go
  - background_join_wiring_test.go
  - capability.go
  - capability_execute_test.go
  - capability_test.go
  - claude_autoseed.go
  - claude_autoseed_test.go
  - client.go
  - client_dial_test.go
  - client_test.go
  - client_timeout_test.go
  - clone_test.go
  - codex_creds_test.go
  - containment_test.go
  - create_identity_gate.go
  - create_identity_gate_test.go
  - credential_mounts.go
  - credential_mounts_test.go
  - disk_test.go
  - doc.go
  - drain_test.go
  - egress.go
  - egress_test.go
  - gateway_auth_test.go
  - gateway_proxy.go
  - gateway_proxy_test.go
  - gateway_ready.go
  - gateway_ready_test.go
  - github_default_test.go
  - github_device_flow.go
  - github_device_flow_test.go
  - github_host_credential.go
  - github_host_credential_test.go
  - github_identity_scope.go
  - github_refresh.go
  - github_refresh_test.go
  - github_repo_create_test.go
  - github_repoint.go
  - github_repoint_test.go
  - github_usage.go
  - grants.go
  - grants_test.go
  - harness_policy.go
  - harness_policy_test.go
  - heartbeat_monitor.go
  - heartbeat_monitor_test.go
  - identity.go
  - identity_test.go
  - idle.go
  - idle_test.go
  - image_build_args_test.go
  - image_staleness.go
  - image_staleness_test.go
  - inject_test.go
  - integration_test.go
  - island_readable.go
  - island_readable_test.go
  - island_reaper_test.go
  - island_secrets.go
  - island_secrets_mount_test.go
  - island_secrets_test.go
  - lineage_test.go
  - link.go
  - link_action.go
  - link_action_test.go
  - link_label_test.go
  - link_routes_test.go
  - link_test.go
  - liveness_test.go
  - llm_mount_drift_test.go
  - llm_reaches_running_island_test.go
  - llm_refresh.go
  - llm_refresh_test.go
  - llmcreds.go
  - llmcreds_test.go
  - local.go
  - local_test.go
  - mailbox.go
  - mailbox_test.go
  - materializer_refresh_test.go
  - mcp.go
  - mcp_test.go
  - metrics.go
  - metrics_test.go
  - no_repo_test.go
  - observed.go
  - ownership_test.go
  - panic.go
  - panic_test.go
  - policy.go
  - policy_consume_repro_test.go
  - port.go
  - port_intake_caps_test.go
  - port_intake_recursive.go
  - port_intake_recursive_test.go
  - port_trade.go
  - port_trade_test.go
  - primary_launch_parity_test.go
  - primer_capability_test.go
  - purge_guard_test.go
  - resources_test.go
  - restart_hint_test.go
  - resume_consistency.go
  - resume_consistency_test.go
  - roleauth.go
  - roleauth_test.go
  - route_visibility_test.go
  - schedule.go
  - schedule_test.go
  - secrets.go
  - secrets_api_test.go
  - selfreap_test.go
  - server.go
  - session.go
  - session_exit_test.go
  - session_restart_test.go
  - session_title_test.go
  - spawn.go
  - spawn_gate_test.go
  - spawn_reaper.go
  - spawn_reaper_test.go
  - spawn_test.go
  - ssh_keys.go
  - surface_coverage_test.go
  - terminals.go
  - tmux_name_default_test.go
  - tokenauth.go
  - tokenauth_test.go
  - tokens.go
  - types.go
  - upgrade_resume_test.go
  - usage_signals_test.go
  - usage_test.go
  - visibility_test.go
  - wake.go
  - wake_test.go
  - watch_test.go
  - watchdog.go
  - watchdog_test.go
  - webhooks.go
  - webhooks_test.go
  - workspace_source.go
  - workspace_source_test.go
- - authtoken.go
  - authtoken_test.go
- - doc.go
  - resize_guard_test.go
  - session.go
  - session_test.go
- - capability.go
  - owner_other.go
  - owner_unix.go
  - registry.go
  - script.go
  - script_test.go
  - shortcuts.go
  - shortcuts_test.go
- - clientcfg.go
  - clientcfg_test.go
  - durability_test.go
  - invite_test.go
- - egress.go
  - egress_test.go
  - env.go
  - policy.go
  - policy_test.go
  - proxy.go
  - proxy_concurrency_test.go
- - catalog_test.go
  - events.go
  - manager.go
- - fdlimit.go
  - fdlimit_test.go
  - guard.go
  - guard_test.go
  - guard_unix.go
  - guard_windows.go
  - raise_unix.go
  - raise_windows.go
- - create_test.go
  - githubid.go
  - githubid_test.go
  - repos.go
  - repos_test.go
  - scope_test.go
- - handlers.go
  - handlers_test.go
  - launchable_test.go
- - hostterm.go
  - hostterm_test.go
- - hosttmux.go
  - hosttmux_test.go
  - tmux-host.conf
- - invite.go
  - invite_test.go
- - codexhook_test.go
  - islandimage.go
  - islandimage_test.go
  - primer_test.go
- - ledger.go
  - ledger_test.go
  - provenance_test.go
- - action.go
  - action_test.go
  - link.go
  - link_test.go
  - tier.go
  - tier_test.go
- - backend.go
  - catalog.go
  - CLAUDE.md
  - install_test.go
  - localmodel_test.go
  - start_test.go
  - start_unix.go
  - start_windows.go
- - mailbox.go
  - mailbox_test.go
- - broker.go
  - mcpbroker.go
  - owner_other.go
  - owner_unix.go
  - registry.go
  - registry_test.go
  - stdio.go
  - stdio_test.go
- - pasteimg.go
  - pasteimg_darwin.go
  - pasteimg_other.go
  - pasteimg_test.go
  - pasteimg_windows.go
- - paths.go
  - paths_test.go
  - read_paths_test.go
- - policy.go
  - policy_test.go
- - porttoken.go
  - porttoken_test.go
  - read_creates_test.go
- - agentref.go
  - agentref_test.go
  - capabilities.go
  - capabilities_test.go
  - doc.go
  - github_host.go
  - legacy_owner_test.go
  - linkactions.go
  - load_no_create_test.go
  - mcp.go
  - mcp_test.go
  - ownership_test.go
  - ports.go
  - project.go
  - project_test.go
  - schedule.go
  - schedule_test.go
- - providercreds.go
  - providercreds_test.go
- - github.go
  - reposrc.go
  - reposrc_test.go
- - bridge.go
  - daemon.go
  - dial.go
  - dial_test.go
  - doc.go
  - docker.go
  - docker_init_test.go
  - docker_reaper_probe_test.go
  - runtime.go
  - volume_copy_test.go
- - island.go
  - island_test.go
  - name.go
  - name_test.go
  - secrets.go
  - secrets_test.go
- - anon_retry_test.go
  - apply.go
  - apply_test.go
  - elevation_advice_test.go
  - meta.go
  - meta_test.go
  - ratelimit_test.go
  - release.go
  - release_elevate_test.go
  - release_test.go
  - resolve_source_test.go
  - selfupdate.go
  - selfupdate_test.go
  - token_fallback_test.go
  - unauthorized_test.go
- - detect.go
  - detect_test.go
  - doc.go
  - fdlimit_test.go
  - launchd.go
  - launchd_system.go
  - service.go
  - sudoers_test.go
  - systemd.go
  - systemd_scope_test.go
- - spawn.go
  - spawn_test.go
- - srcscan.go
  - srcscan_test.go
- - auth.go
  - auth_test.go
  - server.go
  - server_test.go
- - cost.go
  - cost_test.go
- - version.go
  - version_test.go
- - vmmem.go
  - vmmem_test.go
- - device.go
  - device_test.go
  - record.go
  - voicein.go
  - voicein_test.go
- - available_test.go
  - classify_test.go
  - CLAUDE.md
  - coldstart_test.go
  - dial_home_test.go
  - home_test.go
  - probe_liveness_test.go
  - spawn_other.go
  - spawn_test.go
  - spawn_windows.go
  - utf16stream_test.go
  - wsl.go
  - wsl_test.go
- - dejima.js
- - build-platform-packages.mjs
- .gitignore
- package.json
- README.md
- - lib.sh
  - proof-loop.sh
  - teardown.sh
- - clientinstall_test.sh
  - codexheal_test.sh
  - dest.sh
  - dest_test.sh
  - dockerwait.sh
  - dockerwait_test.sh
  - installfork_test.sh
  - ptyrun.py
  - report.sh
  - transcript.sh
  - transcript_test.sh
  - tty.sh
  - tty_test.sh
- - install-totals.sh
- - action-gate.sh
  - lib.sh
  - onboard-selftest.sh
  - reconnect.sh
  - safe.sh
  - system.sh
  - tui-claude.sh
- - agent-smoke.sh
- build-graphics.mjs
- build-og-card.mjs
- docs-index-check.py
- fit-freshness-check.py
- gen-homebrew-formula.sh
- install-channels-check.sh
- integration.sh
- report-to-issue.sh
- setup.sh
- site-claim-check.py
- site-wsl-hint-check.py
- verify-secrets-propagation.sh
- verify-ssh-forward-semantics.sh
- - pyproject.toml
  - README.md
- - package-lock.json
  - package.json
  - README.md
  - tsconfig.json
- .gitignore
- openapi_field_parity.py
- openapi_parity.py
- - manifest.json
  - SKILL.md
- index.html
- keep-agents-off-private-files.html
- team-agent-host.html
.editorconfig
.gitignore
.golangci.yml
.nojekyll
AGENTS.md
api.html
build.html
CLAUDE.md
CNAME
embed.go
fit.txt
go.mod
go.sum
index.html
install-client.ps1
install-client.sh
install.sh
island.html
LICENSE
llms.txt
Makefile
NOTICE
openapi.yaml
quickstart.html
README.md
redocly.yaml
robots.txt
sitemap.xml
STYLE.md
styles.css
teams.html
version.js
walkthrough.js

# CDN으로 사용하기

jsDelivr

jsDelivr는 공개 GitHub 리포지토리를 별도 설정 없이 CDN으로 즉시 서빙합니다. 버전과 파일을 고르면 웹페이지에 바로 붙일 수 있는 링크와 예시 코드가 만들어집니다.

버전

파일

링크

예시

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

<h1 align="center">Dejima</h1>

<p align="center"><em>The secure runtime for isolated AI agents — a fleet per project, on your own infrastructure.</em></p>

---

**Dejima** turns a Mac mini or Linux box into a secure, persistent host for AI agents. Built for **coding agent CLIs** (Claude Code, Codex; Aider/Goose/etc. via custom image), and **usable for any agent that wants isolation, persistence, and an API to drive it** — including headless API-SDK loops via `--agent headless --cmd "…"`.

Each project runs in its own *island*: an isolated container with the target repo, the agent of your choice, and a strictly brokered *bridge* back to the host.

> The name and silhouette borrow from the historical island of Dejima in Nagasaki Bay — a single-bridge trading post, for two centuries the only sanctioned point of contact between Japan and the outside world. Same idea here.

## Status

Alpha — in daily use. v1 milestones M0–M5 are implemented and M6 (a week of real-world dogfood on a Mac mini) is met; rough-edge hardening is ongoing. See [`docs/v1-spec.md`](docs/v1-spec.md) and [`docs/v1-milestones.md`](docs/v1-milestones.md).

## Who it's for

Two audiences, same substrate:

- **You run Claude Code / Codex on your home server.** Multiple projects, each in its own container, attachable from any device on your tailnet, surviving disconnects. The painkiller: no more tmux-session sprawl, no more "which window was I in." `dejima init && dejima connect <name>` and you're in.
- **You're building tooling around agents.** The same HTTP/WebSocket API the CLI uses is yours to target — spawn islands, drive sessions, subscribe to lifecycle/agent events, run one-shot commands. Headless agents (any process, not just terminal CLIs) get the same isolation, volumes, credential mounts, and event hooks; you skip the interactive attach surface. Dejima is the substrate; bring your own LangChain / CrewAI / custom loop. See [`docs/agent-adapters.md`](docs/agent-adapters.md).

A note on "API": throughout the docs, *the Dejima API* refers to Dejima's own HTTP/WebSocket control surface. Upstream LLM provider APIs (Anthropic, OpenAI) are reached by the agents *inside* islands, on their own.

## What you get

- **Isolation** — agents run inside containers with no path to your host filesystem, other projects, or unrelated secrets.
- **Multi-project, multi-agent** — N islands on one host, each its own repo; and N agents *within* an island (one container, per-agent git worktrees, shared credentials/tool-auth). No context bleed between islands. See [`docs/multi-agent-spec.md`](docs/multi-agent-spec.md).
- **Persistent sessions** — long-running agent work survives disconnects and host reboots via tmux + named volumes (interactive agents) or supervised processes with captured logs (headless agents).
- **Multi-device attach** — drive the same island from a laptop, phone, or web client. Shared screen, presence-aware.
- **Direct push to GitHub** — the daemon holds one or more GitHub identities (e.g. `work` and `personal`); each island clones and pushes as the one it picks, so `git push` just works from any device. See [`docs/github-identities.md`](docs/github-identities.md).
- **Egress gate** — island outbound traffic routes through a daemon-run proxy, so you can see every destination each island reaches and allow/deny by host, with no restart. Observe-first by default; disable with `--no-egress-proxy`.
- **Voice dictation** — speak into an island's agent. Capture and transcription (whisper.cpp) run on the machine you're sitting at, on-device; audio never leaves it and only the transcript reaches the island. macOS, Linux, and Windows.
- **API-first** — the CLI is one client of the Dejima API. Mobile apps, Slack bots, custom integrations target the same surface.
- **Host terminals (opt-in)** — resumable, separately-instanced operator shells on the daemon host itself, for server navigation/repair — the tmux+ssh painkiller. Uncontained and operator-only (`dejimad --host-terminals`); agents stay contained. See [`docs/host-terminals.md`](docs/host-terminals.md).

## Setup at a glance

Dejima has two roles:

- **The host** (e.g. your Mac mini). Runs `dejimad` as a launchd/systemd service, owns the islands, holds the workspace volumes. Needs Docker (OrbStack). One per network.
- **Clients** (your laptop, eventually your phone). Just need the `dejima` CLI. Talk to the host via Unix socket locally or via a Tailscale-pinned TCP port remotely.

A first-time setup runs through these in order:

1. Install Docker on the host (OrbStack on macOS).
2. Install `dejima` + `dejimad` on the host; build the island image; install the service.
3. Optionally install `dejima` (just the CLI, no daemon, no Docker) on other devices.
4. `dejima init --repo …` on the host (or any client with `DEJIMA_HOST` set) to create an island.
5. `dejima connect <name>` from any tailnet device to attach.

## Install

The shortest path: **get the `dejima` CLI on the machine you'll drive from, run it, follow the wizard.**

```bash
#    package-manager matrix below. Or build from source with Go 1.26+:
go install github.com/aoos/dejima/cmd/dejima@latest

# 2. Run it. First invocation triggers the setup wizard.
dejima
```

The first-run wizard detects your environment (OS, Docker, Tailscale, dejimad presence) and asks **one** question, with three named destinations:

- **Local** — a daemon on this machine, just for you. Docker and the daemon; no tailnet, nothing kept awake. This is the default and the common case, including on a laptop.
- **Host** — provision this machine as an always-on server for a team: never-sleep, Homebrew, Tailscale, Docker, daemon, in one walkthrough.
- **Client** — connect to a server that already exists; paste the invite.

On Windows, *Local* means a daemon in WSL2 on this same machine (`dejima wsl setup`) — Windows can't run `dejimad` directly, and the wizard says so before you choose rather than after.

`dejima onboard` re-engages the wizard any time. Say "never" at the first-run prompt to opt out; the wizard stays available via `dejima onboard`.

### One-liner installer (skips the wizard)

The curl installer asks the same local/host/client question and then goes all the way:

```bash
curl -fsSL https://dejima.tech/install.sh | bash
```

Answer **Local** (or just press Enter) for a daemon on this machine only — it skips Tailscale and anything always-on. Answer **Host** for the full server stack. To skip the question entirely, say which you want up front:

```bash
# a daemon on this machine, nothing else
curl -fsSL https://dejima.tech/install.sh | DEJIMA_SETUP=local bash

# the full always-on server stack
curl -fsSL https://dejima.tech/install.sh | DEJIMA_SETUP=host bash
```

A run with nobody watching — CI, a provisioning script, a detached shell — stays on **host**, which is what it has always done. Set `DEJIMA_SETUP` to change that; the installer will not decide it for you when there is no one to ask.

That bootstraps everything: installs Homebrew prereqs (Go, Docker Desktop if needed), clones the source to `~/.dejima-src`, builds the `dejima` + `dejimad` binaries, installs them to `/usr/local/bin`, builds the island image, registers the daemon as a launchd (macOS) or systemd user (Linux) service, and runs `dejima doctor` to verify. Idempotent — re-run to update.

> Served from GitHub Pages at the canonical domain `dejima.tech`. The bare GitHub Pages URL (`aoos.github.io/dejima/install.sh`) and the raw fallback (`raw.githubusercontent.com/aoos/dejima/master/install.sh`) resolve to the same script if DNS is mid-propagation.

### One-liner environment knobs

```bash
# Auto-subscribe a push-notification webhook in the same step
curl -fsSL https://dejima.tech/install.sh \
  | NOTIFY_URL=https://ntfy.sh/your-topic bash

# Non-interactive (auto-install Docker without the y/n prompt)
curl -fsSL https://dejima.tech/install.sh \
  | AUTO_INSTALL_DOCKER=1 bash

# Install binaries to ~/.local/bin instead of /usr/local/bin (no sudo)
curl -fsSL https://dejima.tech/install.sh \
  | PREFIX=$HOME/.local bash
```

### Via a package manager (prebuilt binary, no Go)

```bash
# Homebrew (macOS / Linux) — installs the dejima + dejimad binaries
brew install aoos/dejima/dejima

# npm (macOS / Linux / Windows) — installs the dejima CLI client only
npm install -g dejima
```

Both pull the prebuilt binary from the latest [GitHub Release](https://github.com/aoos/dejima/releases) and checksum-verify it against `SHA256SUMS`. On a **host**, you still build the island image + register the daemon (`make image && dejima service install`); the `npm` package is the **client CLI** only.

> Both are **live** as of `v0.7.1` (npm `dejima`, the `aoos/homebrew-dejima` tap) and are kept current automatically by the release workflow on every tag. `brew install --HEAD aoos/dejima/dejima` builds from source off `master`. Full checklist in [`docs/distribution.md`](docs/distribution.md).

> v1 targets macOS (Mac mini priority) and Linux as **hosts** (the machines running `dejimad` + Docker). The `dejima` **client** CLI builds and runs on macOS, Linux, and **Windows** — see *Install (client only)* below. On Windows the daemon can run locally inside **WSL2** (`dejima wsl setup`) — see *Windows: running a host locally* below.
>
> **macOS**: the installer will offer to install [Docker Desktop](https://www.docker.com/products/docker-desktop/) via Homebrew if Docker isn't present. Docker Desktop is free for personal use and small businesses (<250 employees AND <$10M revenue). Faster alternatives if you prefer to install one yourself first: [OrbStack](https://orbstack.dev) (personal-license only) or [colima](https://github.com/abiosoft/colima) (CLI-only, OSS).
>
> **Linux**: install Docker engine natively from your distro (`docker.io` on Debian/Ubuntu, `docker` on Arch/Fedora) before running the installer. No desktop app needed.

## Install (client only)

To drive a remote Dejima daemon from your laptop or desktop, you only need the CLI — no daemon, no Docker. The CLI builds and runs on **macOS, Linux, and Windows**.

> **Tailscale is the network layer** — the daemon only accepts connections that arrive over a tailnet interface. The installers below detect Tailscale and offer to install + sign you in if it's missing. Both server and client must be on the same tailnet.

### Any OS (npm — prebuilt binary)

```bash
npm install -g dejima      # macOS / Linux / Windows
```

Downloads the matching CLI binary from the latest Release and checksum-verifies it; no Go, no Docker. You set up Tailscale + `DEJIMA_HOST` yourself (the curl/PowerShell installers below automate that part).

### macOS / Linux (one-liner — prebuilt binary)

```bash
curl -fsSL https://dejima.tech/install-client.sh | bash
```

The script:
1. Detects + offers to install Tailscale (Homebrew on macOS, official script on Linux), then walks you through `sudo tailscale up`.
2. Downloads the latest CLI release, verifies SHA256, installs to `/usr/local/bin/dejima`.
3. Prompts for your server's tailnet IP (the one `install.sh` printed on the server), probes it on port 7273, and persists `DEJIMA_HOST` to `~/.zshenv` (macOS) or `~/.bashrc` (Linux).

Skip the prompts with `AUTO_INSTALL_TS=1` and `DEJIMA_HOST_PREFILL=100.x.y.z` env vars.

### macOS / Linux (with Go)

```bash
go install github.com/aoos/dejima/cmd/dejima@latest
dejima                # first-run wizard handles DEJIMA_HOST configuration
```

(Doesn't bundle Tailscale install — you set that up separately.)

### Windows (PowerShell — prebuilt binary)

> Open **PowerShell**, not Command Prompt. `irm` and `iex` are PowerShell
> commands; in `cmd.exe` they fail with `'irm' is not recognized as an internal
> or external command`. From Command Prompt, use
> `powershell -NoProfile -Command "irm https://dejima.tech/install-client.ps1 | iex"`
> instead. The same applies to `curl ... | bash` — there is no `bash` in
> `cmd.exe`; that line is for macOS/Linux.

```powershell
irm https://dejima.tech/install-client.ps1 | iex
```

The script:
1. Detects + offers to install Tailscale via `winget`. Points you at the system-tray icon for sign-in (GUI-only on Windows).
2. Downloads `dejima_<ver>_windows_<arch>.zip` from the latest Release, verifies SHA256, extracts to `%LOCALAPPDATA%\dejima`, adds it to your User PATH.
3. Prompts for the server's tailnet IP, probes :7273 via `Test-NetConnection`, persists `DEJIMA_HOST` to the User environment.

Close + reopen PowerShell to pick up the new PATH and env var, then run `dejima`.

The Windows build has full feature parity with macOS/Linux — TUI, `connect`, all verbs. Terminal-resize is polling-based on Windows (vs. SIGWINCH on Unix) but reflows the same way.

### Windows: running a host locally (WSL2)

Windows can't run `dejimad` — the daemon needs a Unix host with Docker. But **WSL2 is
one**, on the same machine, so you don't need a second box to run Dejima locally:

```powershell
wsl --install          # once, in an ADMIN PowerShell; reboot afterwards
dejima wsl setup       # creates the distro, installs Docker + dejimad, connects
```

`dejima wsl setup` provisions a WSL2 distro (named `dejima` by default) with the Docker
engine, `socat`, and `dejimad`, starts the daemon, and saves a `wsl://dejima` connection
profile as your active target. It's idempotent — re-run it after a failed or partial
setup, or after `wsl --shutdown`.

The Windows client reaches that daemon by tunnelling its Unix socket through
`wsl.exe … socat`. **The daemon gets no TCP listener and no token**: its `0600` socket
stays the only operator surface, exactly as on a native Unix host. No Tailscale needed
either — this path never leaves the machine.

| Command | |
|---|---|
| `dejima wsl status` | distro health: WSL version, Docker, dejimad, socket |
| `dejima wsl start` | bring dejimad back up (e.g. after `wsl --shutdown`) |
| `dejima wsl stop` | stop the daemon; `--shutdown` also frees the VM's memory |
| `dejima wsl setup --distro <name>` | use an existing distro instead of creating one |

> Your repos live on the Windows filesystem, but islands clone from git, so that's fine.
> Working directly off `/mnt/c` is slow — prefer a git remote.

If you'd rather point at a server than run one here, that's still the other branch of
`dejima` first-run: `dejima join <invite>`, or
`dejima profile add <name> <host>:7273`.

### If you already know the host and want to skip the wizard

```bash
export DEJIMA_HOST=mac-mini.your-tailnet.ts.net:7273
dejima ls
```

Adding `DEJIMA_HOST` to `~/.zshenv` (or `~/.bash_profile`, or your Windows environment) makes it persistent; the installer above does this for you.

## Updating

Re-run the one-liner. The script does a `git pull` on the existing checkout and re-runs `make setup`. New binaries replace the old; existing islands and the daemon's persisted state are untouched.

## Uninstall

> **Get your work out first.** Dejima never touches your host repo folders — but work done
> *inside* an island lives in that island's Docker volume, and purging destroys it. Before
> removing anything, check each island for uncommitted/unpushed work and push it (or copy
> it out):
>
> ```bash
> dejima exec <name> -- git status     # anything uncommitted or unpushed?
> dejima exec <name> -- git push       # send it to the remote
> dejima cp <name>:/workspace/file ./  # or copy files out directly
> ```

```bash
dejima purge <name>                               # each island: container + volumes
dejima service uninstall                          # stop the daemon
sudo rm /usr/local/bin/dejima /usr/local/bin/dejimad
rm -rf ~/.dejima-src                              # source checkout
rm -rf ~/.dejima                                  # persisted state, config, credential seed
# Leftovers, if you skipped purging some islands:
docker ps -aq --filter label=dejima.project | xargs -r docker rm -f
docker volume ls -q --filter label=dejima.project | xargs -r docker volume rm
docker network ls -q --filter name=dejima-net- | xargs -r docker network rm
```

Docker and Tailscale are left in place — Dejima uses them but didn't install-own them. On a
client device, uninstalling is just deleting the `dejima` binary and removing `DEJIMA_HOST`
from your shell profile.

## Install paths under the hood

If you'd rather see exactly what the installer runs, the equivalent manual flow is:

```bash
git clone https://github.com/aoos/dejima.git ~/.dejima-src
cd ~/.dejima-src
make setup        # detect Docker → build → install → image → service → doctor
```

`make setup` itself is just `scripts/setup.sh`; the one-liner is `install.sh` (repo root, served at `dejima.tech/install.sh`) which adds the prereq-bootstrap + checkout step in front of it. Either is fine.

## Future install paths (roadmap)

- **Homebrew tap** (`brew install aoos/dejima/dejima`) — formula + release-CI auto-bump are wired (`homebrew/dejima.rb`, `scripts/gen-homebrew-formula.sh`); goes live once the `aoos/homebrew-dejima` tap repo + `HOMEBREW_TAP_TOKEN` exist. See [`docs/distribution.md`](docs/distribution.md).
- **npm** (`npm install -g dejima`) — CLI wrapper (`npm/`) + publish job are wired; goes live once `NPM_TOKEN` is set.
- **Signed + notarized macOS binaries** — see [`docs/release-notarization.md`](docs/release-notarization.md). Until then, the installers strip the quarantine attribute on download.
- **homebrew-core** — eventual bare `brew install dejima` without the tap prefix; defer until v1.x has users.

### Install the daemon as a service

```bash
dejima service install     # writes a launchd plist (macOS) or systemd user unit (Linux)
dejima service status      # confirm it's loaded
```

The daemon now runs in the background, survives reboots, and is reachable at `~/.dejima/dejimad.sock`.

You can also subscribe a notification webhook in the same step (e.g. ntfy.sh push to your phone whenever an island event fires):

```bash
dejima service install --notify https://ntfy.sh/your-private-topic
```

### Verify the install

```bash
dejima doctor
```

Reports daemon / Docker / image / Tailscale / project / webhook health with actionable fix hints. Exits non-zero on failure so it composes with scripts.

### Re-engage the setup wizard anytime

```bash
dejima onboard
```

Detects what's already on the machine, asks what you're trying to do (server install / client-only / both / just exploring), and prints a tailored set of commands. Also fires automatically the first time you run `dejima` with no args — say "never" if you don't want it again, "not now" if you want it to ask later.

## Quickstart

```bash
# Create an island around a real GitHub repo.
dejima init --repo git@github.com:you/myproject.git

# Connect — drops you into Claude Code, inside the island.
dejima connect myproject

# Inside the island, ask Claude Code to make a commit and push.
# The push lands on GitHub under your normal git identity.

# Disconnect with Ctrl-b then d (tmux). The session keeps running.

# See what's running.
dejima ls

# Pick up the session from another device on your tailnet:
DEJIMA_HOST=mac-mini.tailnet-name.ts.net:7273 dejima connect myproject

# Pause when memory pressure bites:
dejima hibernate myproject
dejima wake myproject

# Start a fresh conversation but keep the code:
dejima reset myproject

# When you're done:
dejima purge myproject
```

## Multi-device access

The daemon exposes its API on a Unix socket locally (no auth needed; filesystem permissions are the trust boundary) and, optionally, on a Tailscale-pinned TCP port for remote clients:

```bash
# Start the daemon with a TCP listener (only tailnet IPs are accepted).
dejimad --tcp :7273
```

From any other device on your tailnet, point the CLI at the host:

```bash
DEJIMA_HOST=mac-mini:7273 dejima ls
```

Multiple devices can attach to the same island session simultaneously. Each sees the same screen; presence lists who else is connected.

## Concepts

| Term     | Meaning                                                       |
|----------|---------------------------------------------------------------|
| Island   | The container holding one project and one or more agents.   |
| Agent    | A CLI (Claude Code, Codex) or headless process in an island, on its own git worktree. |
| Bridge   | The brokered I/O channel between host and island.            |
| Trade    | A synced export of changes from island to host.              |
| Intake   | Files passed into the island via `dejima import`.            |
| Ledger   | (Post-v1) An audit log of every bridge transaction.          |

CLI verbs are intentionally functional; the metaphor lives in concept names, status output, and docs.

## CLI reference

```text
dejima init      Provision a new island.
dejima connect   Attach to an island's session (multi-attach).
dejima ls        List all islands.
dejima status    Detail view of a single island, including presence.
dejima hibernate Stop the container, preserve volumes.
dejima wake      Start a hibernated island.
dejima reset     Erase every agent's memory (conversations + tool logins). Keeps the workspace.
dejima upgrade   Recreate container(s) on the current island image; all state kept.
dejima purge     Destroy island and volumes.
dejima exec      Run a one-shot command inside an island.
dejima cp        Copy files in or out of an island.
dejima logs      Tail an island's container logs (--follow).
dejima auth      Manage daemon credentials: Claude login + GitHub identities (push [--github]/status).
dejima doctor    Health check: daemon, Docker, image, projects, networks, webhooks.
dejima image     Build the island image on the daemon host (no source checkout needed).
dejima onboard   Walk through Dejima setup; safe to re-run.
dejima service   Install / uninstall / restart dejimad as a host service (--notify <url>).
dejima webhook   Subscribe a URL to receive state-change events.
```

Short alias: `alias dj=dejima` in your shell config if you want fewer keystrokes.

## Webhooks (for integrating from other apps)

```bash
# Get notified when an agent finishes a task or needs your input.
dejima webhook subscribe --url https://ntfy.sh/your-private-topic
```

Events fired by the daemon include lifecycle (`island.created`, `island.hibernated`, etc.), presence (`client.attached`, `client.detached`), and — when the Claude Code shim is active — agent-emitted events (`agent.waiting-for-input`, `agent.task-complete`).

This is the integration point for Slack / Discord / Telegram bots, mobile push, custom dashboards, etc. The Dejima daemon stays agnostic about what's on the other end of the URL.

## Architecture (one-paragraph)

`dejimad` is the host daemon. It manages island containers via the Docker API, exposes the [Dejima HTTP API](docs/v1-spec.md#the-dejima-api-concept) over a Unix socket (and optionally a Tailscale-pinned TCP port), and mediates PTY streams between clients and the in-container tmux session. Containers stay running across reboots; their volumes hold workspace and agent on-disk state. Per-agent shims (currently Claude Code) live in `image/agents/<agent>/` and provide opt-in conveniences without contaminating the agnostic core.

## Troubleshooting

| Symptom                                               | Fix                                                                                 |
|-------------------------------------------------------|-------------------------------------------------------------------------------------|
| `daemon unreachable: is dejimad running?`             | `dejima service status` or run `dejimad --foreground` for debug logs.               |
| `image dejima/island:latest not found locally`        | Run `make image`. The first build takes a few minutes.                              |
| `docker: command not found` / daemon not reachable    | Install Docker Desktop (or OrbStack / colima). On Linux: `sudo apt install docker.io` (or distro equivalent).|
| `gh auth setup-git failed`                            | `gh auth login` on the host; restart the island (`dejima reset <name>`).            |
| Agent can't push to GitHub                            | `dejima auth status` — seed an identity with `dejima auth push --github`, or `gh auth login` on the daemon host. See [`docs/github-identities.md`](docs/github-identities.md).|
| TCP listener: connection refused from off-tailnet     | This is intentional. Only tailnet IPs are accepted on the TCP listener.             |
| Memory creeping over time                             | `dejima hibernate <name>` then `dejima wake <name>` for a clean restart.            |

For more, see [`docs/v1-spec.md`](docs/v1-spec.md).

## Roadmap

See [`docs/roadmap.md`](docs/roadmap.md) for the full prioritized list. Highlights:

- **v1.x hardening** — container watchdog, `panic`, Keychain-backed secrets, idle auto-hibernate. (`upgrade` and credential refresh have shipped.)
- **Per-island secrets manager** — managed storage for the tokens agents' tools need, so they stop living in repos and shell profiles. Deliberately does *not* hide values from agents in the island; see [`docs/secrets-manager-spec.md`](docs/secrets-manager-spec.md).
- **v2** — trust-on-first-use for new device attaches (the 2FA-shaped feature), audit ledger, backup/restore, microVM backend, MCP brokering, multi-user / RBAC, web/PWA reference client.
- **Tier-2 integrations** (separate repos): `dejima-slack`, `dejima-telegram`, ntfy.sh and macOS notification helpers.

## License

Not yet chosen — to be decided before the repo goes public.

dejima

파일 탐색기

# CDN으로 사용하기

Was this content helpful?

Recent Feedback

Download README