dsh-remote-local-plugin 0.0.0-stage → 0.8.0

package/lib/index.js

@@ -0,0 +1,4565 @@
+/* dsh-remote-local-plugin@0.8.0 — bundled host entry */
+
+// src/index.ts
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+
+// src/config.ts
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+import z from "@deepseek-ai/schemastery";
+var Config = z.object({
+  stateDir: z.string().default(""),
+  sshBinary: z.string().default("ssh"),
+  remoteStateFile: z.string().default(""),
+  probeTimeoutMs: z.number().min(1e3).max(12e4).default(1e4),
+  connectTimeoutMs: z.number().min(1e3).max(12e4).default(15e3),
+  healthIntervalMs: z.number().min(2e3).max(6e5).default(15e3),
+  reconnect: z.boolean().default(true),
+  maxReconnectDelayMs: z.number().min(1e3).max(6e5).default(3e4),
+  strictHostKeyChecking: z.string().default("accept-new"),
+  autoProvision: z.boolean().default(true),
+  remoteDshHome: z.string().default("~/.dsh"),
+  remoteInstallDir: z.string().default("~/.local/share/dsh-remote"),
+  remoteDshVersion: z.string().default("0.2.1-rc.2"),
+  remotePnpmVersion: z.string().default("11.21.0"),
+  remoteNodeVersion: z.string().default("22.19.0"),
+  autoInstallNode: z.boolean().default(true),
+  remoteStart: z.string().default("systemd"),
+  provisionTimeoutMs: z.number().min(6e4).max(18e5).default(6e5),
+  credentialProxy: z.boolean().default(false),
+  copyModelKey: z.boolean().default(true),
+  remoteModelBaseUrl: z.string().default("https://api.deepseek.com/anthropic"),
+  credentialProxyUpstream: z.string().default("https://api.deepseek.com/anthropic"),
+  credentialProxyRemotePort: z.number().min(1).max(65535).default(47821),
+  modelCredentialRef: z.string().default("DEEPSEEK_API_KEY"),
+  mirrorSessions: z.boolean().default(true),
+  mirrorPollMs: z.number().min(500).max(3e4).default(1500),
+  mirrorMaxEvents: z.number().min(100).max(1e4).default(2e3)
+});
+function resolveDshHome(env = process.env) {
+  const configured = env.DSH_HOME;
+  if (configured !== void 0 && configured.trim() !== "") return resolve(configured);
+  return join(homedir(), ".dsh");
+}
+function resolveLocalPath(path, home = resolveDshHome()) {
+  const trimmed = path.trim();
+  if (trimmed === "") return join(home, "remote");
+  if (trimmed === "~") return home;
+  if (trimmed.startsWith("~/")) return join(home, trimmed.slice(2));
+  return isAbsolute(trimmed) ? trimmed : resolve(home, trimmed);
+}
+function joinRemotePath(base, suffix) {
+  const trimmed = base.trim();
+  if (trimmed === "" || trimmed === "~") return `~/${suffix}`;
+  return `${trimmed.replace(/\/+$/u, "")}/${suffix}`;
+}
+function resolveConfig(config = {}, env = process.env) {
+  const strict = config.strictHostKeyChecking ?? "accept-new";
+  if (strict !== "yes" && strict !== "no" && strict !== "ask" && strict !== "accept-new") {
+    throw new Error(`invalid strictHostKeyChecking: ${JSON.stringify(strict)}`);
+  }
+  const remoteStart = config.remoteStart ?? "systemd";
+  if (remoteStart !== "systemd" && remoteStart !== "nohup" && remoteStart !== "none") {
+    throw new Error(`invalid remoteStart: ${JSON.stringify(remoteStart)}`);
+  }
+  const remoteDshHome = config.remoteDshHome ?? "~/.dsh";
+  const configuredStateFile = (config.remoteStateFile ?? "").trim();
+  return {
+    stateDir: resolveLocalPath(config.stateDir ?? "", resolveDshHome(env)),
+    sshBinary: (config.sshBinary ?? "ssh").trim() || "ssh",
+    remoteStateFile: configuredStateFile === "" ? joinRemotePath(remoteDshHome, "remote-agent/agent.json") : configuredStateFile,
+    probeTimeoutMs: config.probeTimeoutMs ?? 1e4,
+    connectTimeoutMs: config.connectTimeoutMs ?? 15e3,
+    healthIntervalMs: config.healthIntervalMs ?? 15e3,
+    reconnect: config.reconnect ?? true,
+    maxReconnectDelayMs: config.maxReconnectDelayMs ?? 3e4,
+    strictHostKeyChecking: strict,
+    autoProvision: config.autoProvision ?? true,
+    remoteDshHome,
+    remoteInstallDir: config.remoteInstallDir ?? "~/.local/share/dsh-remote",
+    remoteDshVersion: config.remoteDshVersion ?? "0.2.1-rc.2",
+    remotePnpmVersion: config.remotePnpmVersion ?? "11.21.0",
+    remoteNodeVersion: config.remoteNodeVersion ?? "22.19.0",
+    autoInstallNode: config.autoInstallNode ?? true,
+    remoteStart,
+    provisionTimeoutMs: config.provisionTimeoutMs ?? 6e5,
+    credentialProxy: config.credentialProxy ?? false,
+    copyModelKey: config.copyModelKey ?? true,
+    remoteModelBaseUrl: config.remoteModelBaseUrl ?? "https://api.deepseek.com/anthropic",
+    credentialProxyUpstream: config.credentialProxyUpstream ?? "https://api.deepseek.com/anthropic",
+    credentialProxyRemotePort: config.credentialProxyRemotePort ?? 47821,
+    modelCredentialRef: config.modelCredentialRef ?? "DEEPSEEK_API_KEY",
+    mirrorSessions: config.mirrorSessions ?? true,
+    mirrorPollMs: config.mirrorPollMs ?? 1500,
+    mirrorMaxEvents: config.mirrorMaxEvents ?? 2e3
+  };
+}
+
+// src/errors.ts
+var LocalError = class extends Error {
+  code;
+  details;
+  retryable;
+  constructor(code, message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "LocalError";
+    this.code = code;
+    this.details = options.details ?? {};
+    this.retryable = options.retryable ?? (code === "agent/unavailable" || code === "internal");
+  }
+};
+function asLocalError(error, fallback = "internal") {
+  if (error instanceof LocalError) return error;
+  const message = error instanceof Error && error.message !== "" ? error.message : "remote host operation failed";
+  return new LocalError(fallback, message, { cause: error });
+}
+
+// src/remote/directory.ts
+import { spawn } from "node:child_process";
+var LISTER = String.raw`
+import json, os, sys
+raw = sys.argv[1] if len(sys.argv) > 1 else '~'
+path = os.path.abspath(os.path.expanduser(raw))
+parent = os.path.dirname(path.rstrip('/')) or '/'
+entries = []
+with os.scandir(path) as it:
+    for entry in it:
+        try:
+            if not entry.is_dir(follow_symlinks=True):
+                continue
+            entries.append({'name': entry.name, 'path': os.path.join(path, entry.name)})
+        except OSError:
+            continue
+entries.sort(key=lambda item: item['name'].lower())
+print(json.dumps({
+    'path': path,
+    'parent': parent,
+    'entries': entries[:500],
+    'truncated': len(entries) > 500,
+}))
+`;
+async function listRemoteDirectories(hosts, hostId, path = "~") {
+  const ssh = hosts.sshFor(hostId);
+  const args = [
+    "-o",
+    "BatchMode=yes",
+    "-o",
+    "ConnectTimeout=10000",
+    ...ssh.port === null ? [] : ["-p", String(ssh.port)],
+    ssh.target,
+    "python3",
+    "-c",
+    `'import base64;exec(base64.b64decode("${Buffer.from(LISTER).toString("base64")}"))'`,
+    path
+  ];
+  const output = await new Promise((resolve4, reject) => {
+    const child = spawn(ssh.binary, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve4(stdout);
+      else reject(new LocalError("directory/unreadable", stderr.trim() || `remote directory listing exited with ${String(code)}`));
+    });
+  });
+  try {
+    const parsed = JSON.parse(output);
+    if (typeof parsed.path !== "string" || typeof parsed.parent !== "string" || !Array.isArray(parsed.entries)) {
+      throw new Error("invalid directory listing");
+    }
+    return parsed;
+  } catch (error) {
+    throw new LocalError("directory/unreadable", `remote directory listing returned invalid JSON: ${String(error)}`);
+  }
+}
+
+// src/remote/local-directory.ts
+import { readdir, stat } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname, resolve as resolve2 } from "node:path";
+function normalize(path) {
+  const raw = (path ?? "").trim();
+  if (raw === "" || raw === "~") return homedir2();
+  if (raw.startsWith("~/")) return resolve2(homedir2(), raw.slice(2));
+  return resolve2(raw);
+}
+async function listLocalDirectories(path) {
+  const target = normalize(path);
+  try {
+    const names = await readdir(target);
+    const entries = [];
+    for (const name2 of names.sort((a, b) => a.localeCompare(b))) {
+      try {
+        if ((await stat(resolve2(target, name2))).isDirectory()) {
+          entries.push({ name: name2, path: resolve2(target, name2) });
+        }
+      } catch {
+      }
+    }
+    return {
+      path: target,
+      parent: dirname(target) || target,
+      entries: entries.slice(0, 500),
+      truncated: entries.length > 500
+    };
+  } catch (error) {
+    throw new LocalError("directory/unreadable", `could not read local directory ${target}: ${String(error)}`);
+  }
+}
+
+// src/host-api/contract.ts
+var HOST_API_PATH = "/api/dsh-remote";
+
+// src/host-api/handler.ts
+function registerHostApi(ctx, service, mirrors) {
+  return ctx.connection.fetch.register({
+    path: HOST_API_PATH,
+    methods: ["POST"],
+    requestBody: "buffered",
+    fetch: (request) => handleHostApi(ctx, service, mirrors, request)
+  });
+}
+async function handleHostApi(ctx, service, mirrors, request) {
+  let body;
+  try {
+    body = await request.json();
+  } catch (error) {
+    return jsonResult({
+      ok: false,
+      error: {
+        code: "request/invalid",
+        message: "request body must be JSON",
+        details: {}
+      }
+    });
+  }
+  if (typeof body !== "object" || body === null || typeof body.endpoint !== "string") {
+    return jsonResult({
+      ok: false,
+      error: { code: "request/invalid", message: "request.endpoint must be a string", details: {} }
+    });
+  }
+  try {
+    const value = await dispatch(ctx, service, mirrors, body.endpoint, body.payload);
+    return jsonResult({ ok: true, value });
+  } catch (error) {
+    const failure = asLocalError(error);
+    return jsonResult({
+      ok: false,
+      error: {
+        code: failure.code,
+        message: failure.message,
+        details: failure.details
+      }
+    });
+  }
+}
+async function dispatch(ctx, service, mirrors, endpoint, payload) {
+  switch (endpoint) {
+    case "state":
+      return service.state();
+    case "target/validate":
+      return service.validateTarget(requireStringField(payload, "sshTarget"));
+    case "host/add": {
+      const body = requireRecord(payload);
+      return service.add({
+        sshTarget: requireStringField(body, "sshTarget"),
+        ...optionalStringField(body, "label") === void 0 ? {} : { label: optionalStringField(body, "label") },
+        ...optionalStringField(body, "token") === void 0 ? {} : { token: optionalStringField(body, "token") },
+        ...optionalNumberField(body, "remoteAgentPort") === void 0 ? {} : { remoteAgentPort: optionalNumberField(body, "remoteAgentPort") },
+        ...optionalBooleanField(body, "autoConnect") === void 0 ? {} : { autoConnect: optionalBooleanField(body, "autoConnect") }
+      });
+    }
+    case "host/remove": {
+      const body = requireRecord(payload);
+      await service.remove(requireStringField(body, "hostId"));
+      return { removed: true };
+    }
+    case "host/connect":
+      return service.connect(requireStringField(payload, "hostId"));
+    case "host/disconnect":
+      return service.disconnect(requireStringField(payload, "hostId"));
+    case "host/refresh":
+      return service.refresh(requireStringField(payload, "hostId"));
+    case "host/provision":
+      return service.provision(requireStringField(payload, "hostId"));
+    case "host/workspaces": {
+      const hostId = requireStringField(payload, "hostId");
+      const workspaces = await service.workspaces(hostId);
+      return {
+        workspaces: workspaces.filter((workspace) => mirrors?.isTestHidden(workspace.workspaceId, workspace.path) !== true).map((workspace) => {
+          const localWorkspaceId = mirrors?.localWorkspaceId(hostId, workspace.workspaceId);
+          return localWorkspaceId === void 0 ? workspace : { ...workspace, localWorkspaceId };
+        })
+      };
+    }
+    case "host/workspace/create": {
+      const body = requireRecord(payload);
+      return service.createWorkspace(requireStringField(body, "hostId"), {
+        path: requireStringField(body, "path"),
+        ...optionalStringField(body, "title") === void 0 ? {} : { title: optionalStringField(body, "title") }
+      });
+    }
+    case "host/directory/list": {
+      const body = requireRecord(payload);
+      return listRemoteDirectories(service, requireStringField(body, "hostId"), optionalStringField(body, "path") ?? "~");
+    }
+    case "local/directory/list": {
+      const body = requireRecord(payload);
+      return listLocalDirectories(optionalStringField(body, "path"));
+    }
+    case "local/workspace/create": {
+      const body = requireRecord(payload);
+      const registry = ctx.get("workspaceRegistry");
+      if (registry === void 0) throw new LocalError("agent/unavailable", "workspace registry is unavailable");
+      const workspace = await registry.create(
+        requireStringField(body, "path"),
+        optionalStringField(body, "title")
+      );
+      return { workspaceId: String(workspace.id) };
+    }
+    case "host/sessions": {
+      const body = requireRecord(payload);
+      return service.sessions(
+        requireStringField(body, "hostId"),
+        optionalStringField(body, "workspaceId")
+      );
+    }
+    case "host/session": {
+      const body = requireRecord(payload);
+      return service.snapshot(
+        requireStringField(body, "hostId"),
+        requireStringField(body, "sessionId"),
+        optionalNumberField(body, "limit")
+      );
+    }
+    case "host/session/create": {
+      const body = requireRecord(payload);
+      const hostId = requireStringField(body, "hostId");
+      const created = await service.createSession(hostId, {
+        ...optionalStringField(body, "workspaceId") === void 0 ? {} : { workspaceId: optionalStringField(body, "workspaceId") },
+        ...optionalStringField(body, "cwd") === void 0 ? {} : { cwd: optionalStringField(body, "cwd") },
+        ...optionalStringField(body, "agentPreset") === void 0 ? {} : { agentPreset: optionalStringField(body, "agentPreset") }
+      });
+      const localSessionId = await mirrors?.ensureRemoteSession(hostId, created.sessionId);
+      return { ...created, ...localSessionId === void 0 ? {} : { localSessionId } };
+    }
+    case "host/session/prompt": {
+      const body = requireRecord(payload);
+      const mode = optionalStringField(body, "mode");
+      if (mode !== void 0 && mode !== "queue" && mode !== "steer") {
+        throw new LocalError("request/invalid", "mode must be queue or steer");
+      }
+      const provider = optionalStringField(body, "provider");
+      const model = optionalStringField(body, "model");
+      const reasoningEffort = optionalStringField(body, "reasoningEffort");
+      return service.promptSession(
+        requireStringField(body, "hostId"),
+        requireStringField(body, "sessionId"),
+        requireStringField(body, "text"),
+        mode,
+        provider === void 0 || model === void 0 ? void 0 : { provider, model, ...reasoningEffort === void 0 ? {} : { reasoningEffort } }
+      );
+    }
+    case "host/session/cancel": {
+      const body = requireRecord(payload);
+      return service.cancelSession(
+        requireStringField(body, "hostId"),
+        requireStringField(body, "sessionId")
+      );
+    }
+    case "host/web-url":
+      return service.webUrl(requireStringField(payload, "hostId"));
+    case "host/files/list":
+    case "host/files/read":
+    case "host/files/stat":
+    case "host/files/bytes": {
+      const body = requireRecord(payload);
+      const sessionId = requireStringField(body, "sessionId");
+      const path = requireStringField(body, "path");
+      const sessions = ctx.get("sessions");
+      const session = sessions?.get(sessionId);
+      const root = session?.header.cwd;
+      if (root === void 0 || mirrors?.remoteFileContext(root) === void 0) return { mirrored: false };
+      const files = ctx.get("workspaceFiles");
+      if (files === void 0) return { mirrored: false };
+      const scope = { sessionId, workspaceRoot: root };
+      const signal = new AbortController().signal;
+      if (endpoint === "host/files/list") return { mirrored: true, value: await files.list(scope, path, signal) };
+      if (endpoint === "host/files/stat") return { mirrored: true, value: await files.stat(scope, path, signal) };
+      if (endpoint === "host/files/bytes") return { mirrored: true, value: await files.readBytes(scope, path, {
+        range: {
+          ...body.offset === void 0 ? {} : { offset: body.offset },
+          ...body.length === void 0 ? {} : { length: body.length }
+        }
+      }, signal) };
+      return { mirrored: true, value: await files.read(scope, path, {
+        ...body.offset === void 0 ? {} : { offset: body.offset },
+        ...body.limit === void 0 ? {} : { limit: body.limit }
+      }, signal) };
+    }
+    default:
+      throw new LocalError("request/invalid", `unknown remote-host endpoint: ${JSON.stringify(endpoint)}`);
+  }
+}
+function jsonResult(result) {
+  return Response.json(result, {
+    status: 200,
+    headers: { "cache-control": "no-store" }
+  });
+}
+function requireRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new LocalError("request/invalid", "payload must be a JSON object");
+  }
+  return value;
+}
+function requireStringField(value, field) {
+  const record = requireRecord(value);
+  const fieldValue = record[field];
+  if (typeof fieldValue !== "string" || fieldValue.trim() === "") {
+    throw new LocalError("request/invalid", `payload.${field} must be a non-empty string`);
+  }
+  return fieldValue.trim();
+}
+function optionalStringField(value, field) {
+  const record = requireRecord(value);
+  const fieldValue = record[field];
+  if (fieldValue === void 0 || fieldValue === null) return void 0;
+  if (typeof fieldValue !== "string") {
+    throw new LocalError("request/invalid", `payload.${field} must be a string`);
+  }
+  return fieldValue;
+}
+function optionalNumberField(value, field) {
+  const record = requireRecord(value);
+  const fieldValue = record[field];
+  if (fieldValue === void 0 || fieldValue === null) return void 0;
+  if (typeof fieldValue !== "number" || !Number.isFinite(fieldValue)) {
+    throw new LocalError("request/invalid", `payload.${field} must be a number`);
+  }
+  return fieldValue;
+}
+function optionalBooleanField(value, field) {
+  const record = requireRecord(value);
+  const fieldValue = record[field];
+  if (fieldValue === void 0 || fieldValue === null) return void 0;
+  if (typeof fieldValue !== "boolean") {
+    throw new LocalError("request/invalid", `payload.${field} must be a boolean`);
+  }
+  return fieldValue;
+}
+
+// src/mirror/service.ts
+import { createHash, randomUUID } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { mkdir, readFile as readFile2, rename, writeFile } from "node:fs/promises";
+import { join as join3 } from "node:path";
+import { scopeTarget } from "@deepseek-ai/dsh-scope";
+
+// src/mirror/test-visibility.ts
+import { readFile } from "node:fs/promises";
+import { join as join2 } from "node:path";
+var EMPTY = { hiddenPaths: [], hiddenWorkspaceIds: [] };
+async function loadTestVisibility(stateDir) {
+  try {
+    const raw = await readFile(join2(stateDir, "test-visibility.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      hiddenPaths: Array.isArray(parsed.hiddenPaths) ? parsed.hiddenPaths.filter((item) => typeof item === "string") : [],
+      hiddenWorkspaceIds: Array.isArray(parsed.hiddenWorkspaceIds) ? parsed.hiddenWorkspaceIds.filter((item) => typeof item === "string") : []
+    };
+  } catch {
+    return EMPTY;
+  }
+}
+function isTestHidden(remotePath, remoteWorkspaceId, visibility) {
+  if (visibility.hiddenWorkspaceIds.includes(remoteWorkspaceId)) return true;
+  const path = remotePath.trim().replace(/\/+$/u, "") || "/";
+  return visibility.hiddenPaths.some((prefix) => {
+    const root = prefix.trim().replace(/\/+$/u, "") || "/";
+    return path === root || path.startsWith(`${root}/`);
+  });
+}
+
+// src/mirror/service.ts
+var MIRROR_VERSION = 1;
+var SURFACE_TYPES = /* @__PURE__ */ new Set([
+  "system/message",
+  "developer/message",
+  "user/message",
+  "assistant/message",
+  "tool/result"
+]);
+var RemoteMirrorAgent = class {
+  id;
+  session;
+  options;
+  ctx;
+  inbox = { "next-turn": [], "next-step": [], nextTurn: [], nextStep: [] };
+  #runtime;
+  #mirror;
+  constructor(mirror, runtime, ctx, options) {
+    this.#mirror = mirror;
+    this.#runtime = runtime;
+    this.id = runtime.session.id;
+    this.session = runtime.session;
+    this.ctx = ctx;
+    this.options = options;
+  }
+  get status() {
+    return this.#runtime.running ? "running" : "idle";
+  }
+  cancel() {
+    this.#mirror.cancel(this.#runtime);
+  }
+  whenIdle() {
+    if (!this.#runtime.running) return Promise.resolve();
+    return new Promise((resolve4) => {
+      this.#runtime.waiters.push(resolve4);
+    });
+  }
+  runMaintenance(task) {
+    return task(new AbortController().signal);
+  }
+  send(message, _target, wakeup = false) {
+    if (wakeup) this.followup(message);
+    else this.#mirror.prompt(this.#runtime, message, "queue");
+  }
+  followup(message) {
+    this.#mirror.prompt(this.#runtime, message, "queue");
+  }
+  steer(message) {
+    this.#mirror.prompt(this.#runtime, message, "steer");
+  }
+  inject() {
+  }
+};
+var RemoteMirrorService = class {
+  get #sessions() {
+    const value = this.#ctx.get("sessions");
+    if (value === void 0) throw new Error("dsh-remote-local: sessions service is unavailable");
+    return value;
+  }
+  get #workspaceRegistry() {
+    const value = this.#ctx.get("workspaceRegistry");
+    if (value === void 0) throw new Error("dsh-remote-local: workspaceRegistry service is unavailable");
+    return value;
+  }
+  get #agents() {
+    const value = this.#ctx.get("agents");
+    if (value === void 0) throw new Error("dsh-remote-local: agents service is unavailable");
+    return value;
+  }
+  #ctx;
+  #hosts;
+  #config;
+  #state = { version: MIRROR_VERSION, sessions: {}, workspaces: {}, testHidden: [] };
+  #testVisibility = { hiddenPaths: [], hiddenWorkspaceIds: [] };
+  #runtimes = /* @__PURE__ */ new Map();
+  #registrations = /* @__PURE__ */ new Map();
+  #approvalStreams = /* @__PURE__ */ new Map();
+  #syncing = false;
+  #saveQueue = Promise.resolve();
+  #timer;
+  #disposed = false;
+  constructor(ctx, hosts, config) {
+    this.#ctx = ctx;
+    this.#hosts = hosts;
+    this.#config = config;
+  }
+  /** Load mappings and begin periodic discovery. */
+  async start() {
+    await this.#load();
+    if (!this.#config.mirrorSessions) return;
+    this.#timer = setInterval(() => {
+      void this.sync();
+    }, Math.max(5e3, this.#config.mirrorPollMs * 4));
+    await this.sync();
+  }
+  /** Stop mirrors and timers. */
+  async dispose() {
+    this.#disposed = true;
+    if (this.#timer !== void 0) clearInterval(this.#timer);
+    for (const runtime of this.#runtimes.values()) {
+      runtime.stopped = true;
+      if (runtime.timer !== void 0) clearTimeout(runtime.timer);
+    }
+    for (const dispose of this.#registrations.values()) dispose();
+    this.#registrations.clear();
+    for (const controller of this.#approvalStreams.values()) controller.abort();
+    this.#approvalStreams.clear();
+    this.#runtimes.clear();
+    await this.#save();
+  }
+  /** Reconcile connected hosts with the local workspace/session catalog. */
+  async sync() {
+    if (this.#disposed || this.#syncing) return;
+    this.#syncing = true;
+    try {
+      this.#testVisibility = await loadTestVisibility(this.#config.stateDir);
+      for (const host of this.#hosts.list()) {
+        if (host.phase !== "connected") continue;
+        try {
+          await this.#syncHost(host);
+        } catch (error) {
+          this.#ctx.logger.warn("dsh-remote-local: mirror sync for %s failed: %s", host.id, String(error));
+        }
+      }
+    } finally {
+      this.#syncing = false;
+    }
+  }
+  /** Resolve a local workspace anchor to its remote filesystem context. */
+  remoteFileContext(workspaceRoot) {
+    const root = canonicalPath(workspaceRoot);
+    for (const record of Object.values(this.#state.workspaces)) {
+      if (record.remoteRoot === void 0) continue;
+      const anchor = canonicalPath(record.anchor);
+      if (root === anchor || root.startsWith(`${anchor}/`)) {
+        return { hostId: record.hostId, remoteRoot: record.remoteRoot, anchor };
+      }
+    }
+    return void 0;
+  }
+  /** Whether the test-only manifest excludes this remote workspace from UI listings. */
+  isTestHidden(remoteWorkspaceId, remotePath) {
+    return isTestHidden(remotePath, remoteWorkspaceId, this.#testVisibility);
+  }
+  /** Find the local mirror workspace for one remote workspace. */
+  localWorkspaceId(hostId, remoteWorkspaceId) {
+    return this.#state.workspaces[key(hostId, remoteWorkspaceId)]?.localWorkspaceId;
+  }
+  /** Find the local mirror for one remote session. */
+  localSessionId(hostId, remoteSessionId) {
+    return this.#state.sessions[key(hostId, remoteSessionId)]?.localSessionId;
+  }
+  /** Create a mirror on demand and return its local session id. */
+  async ensureRemoteSession(hostId, remoteSessionId) {
+    const host = this.#hosts.list().find((item) => item.id === hostId);
+    if (host === void 0 || host.phase !== "connected") return void 0;
+    const existing = this.localSessionId(hostId, remoteSessionId);
+    if (existing !== void 0 && this.#sessions.get(existing) !== void 0) return existing;
+    const workspaces = await this.#hosts.workspaces(hostId);
+    for (const workspace of workspaces) {
+      if (isTestHidden(workspace.path, workspace.workspaceId, this.#testVisibility)) continue;
+      const sessions = await this.#hosts.sessions(hostId, workspace.workspaceId);
+      const summary2 = sessions.sessions.find((item) => item.sessionId === remoteSessionId);
+      if (summary2 === void 0) continue;
+      const localWorkspace2 = await this.#ensureWorkspace(host, workspace);
+      const record = await this.#ensureMirror(host, summary2, localWorkspace2, workspace.path);
+      return record?.localSessionId;
+    }
+    const all = await this.#hosts.sessions(hostId);
+    const summary = all.sessions.find((item) => item.sessionId === remoteSessionId);
+    if (summary === void 0) return void 0;
+    if (summary.cwd !== null && isTestHidden(summary.cwd, "", this.#testVisibility)) return void 0;
+    const localWorkspace = await this.#ensureUngroupedWorkspace(host, summary.cwd ?? "ungrouped");
+    return (await this.#ensureMirror(host, summary, localWorkspace.workspace, localWorkspace.anchor))?.localSessionId;
+  }
+  /** Route one prompt from the local Agent façade to the remote session. */
+  prompt(runtime, message, mode) {
+    const text = contentText(message);
+    if (text === "") return;
+    runtime.pendingUsers.push(message);
+    this.#setRunning(runtime, true);
+    if (runtime.stopped || runtime.timer === void 0) {
+      runtime.stopped = false;
+      runtime.lastError = null;
+      this.#schedule(runtime);
+    }
+    void this.#hosts.promptSession(
+      runtime.record.hostId,
+      runtime.record.remoteSessionId,
+      text,
+      mode,
+      latestSelection(runtime.session)
+    ).catch((error) => {
+      runtime.lastError = error instanceof Error ? error.message : String(error);
+      runtime.pendingUsers.shift();
+      this.#ctx.logger.warn("dsh-remote-local: remote prompt failed: %s", runtime.lastError);
+      this.#setRunning(runtime, false);
+    });
+  }
+  /** Route cancellation to the remote session. */
+  cancel(runtime) {
+    void this.#hosts.cancelSession(runtime.record.hostId, runtime.record.remoteSessionId).catch((error) => {
+      this.#ctx.logger.warn("dsh-remote-local: remote cancel failed: %s", String(error));
+    });
+    this.#setRunning(runtime, false);
+  }
+  async #syncHost(host) {
+    this.#ensureApprovalStream(host);
+    await this.#reconcileTestHidden(host);
+    const workspaces = await this.#hosts.workspaces(host.id);
+    const covered = /* @__PURE__ */ new Set();
+    const byPath = /* @__PURE__ */ new Map();
+    for (const workspace of workspaces) {
+      if (isTestHidden(workspace.path, workspace.workspaceId, this.#testVisibility)) {
+        const sessions2 = await this.#hosts.sessions(host.id, workspace.workspaceId);
+        for (const summary of sessions2.sessions) covered.add(summary.sessionId);
+        continue;
+      }
+      const local = await this.#ensureWorkspace(host, workspace);
+      byPath.set(workspace.path, { workspace: local, anchor: this.#anchorFor(local) });
+      const sessions = await this.#hosts.sessions(host.id, workspace.workspaceId);
+      for (const summary of sessions.sessions) {
+        covered.add(summary.sessionId);
+        await this.#ensureMirror(host, summary, local, workspace.path);
+      }
+    }
+    const all = await this.#hosts.sessions(host.id);
+    for (const summary of all.sessions) {
+      if (covered.has(summary.sessionId)) continue;
+      if (summary.cwd !== null && isTestHidden(summary.cwd, "", this.#testVisibility)) continue;
+      const workspace = summary.cwd === null ? void 0 : byPath.get(summary.cwd);
+      if (workspace !== void 0) {
+        await this.#ensureMirror(host, summary, workspace.workspace, workspace.anchor);
+        continue;
+      }
+      const ungrouped = await this.#ensureUngroupedWorkspace(host, summary.cwd ?? "ungrouped");
+      await this.#ensureMirror(host, summary, ungrouped.workspace, ungrouped.anchor);
+    }
+  }
+  /**
+   * Apply the test-only manifest to already-mirrored workspaces. Hidden entries
+   * archive local Sessions and remove the local workspace row; removing an
+   * entry unarchives the Sessions and lets the normal sync rebuild the row.
+   */
+  async #reconcileTestHidden(host) {
+    let changed = false;
+    const entries = Object.entries(this.#state.workspaces).filter(([, record]) => record.hostId === host.id);
+    for (const [ref, record] of entries) {
+      const hidden = record.remoteRoot !== void 0 && isTestHidden(record.remoteRoot, record.remoteWorkspaceId ?? "", this.#testVisibility);
+      const tracked = this.#state.testHidden.includes(ref);
+      if (hidden) {
+        if (record.remoteRoot === void 0 || tracked) continue;
+        for (const session of Object.values(this.#state.sessions)) {
+          if (session.hostId !== host.id) continue;
+          if (session.remoteWorkspaceId !== record.remoteWorkspaceId) continue;
+          await this.#archive(session.localSessionId);
+        }
+        try {
+          await this.#workspaceRegistry.delete(record.localWorkspaceId);
+        } catch (error) {
+          this.#ctx.logger.warn("dsh-remote-local: could not hide test workspace %s: %s", ref, String(error));
+        }
+        this.#state.testHidden.push(ref);
+        changed = true;
+      } else if (tracked) {
+        for (const session of Object.values(this.#state.sessions)) {
+          if (session.hostId !== host.id) continue;
+          if (session.remoteWorkspaceId !== record.remoteWorkspaceId) continue;
+          try {
+            await this.#workspaceRegistry.unarchiveSession(session.localSessionId);
+          } catch {
+          }
+        }
+        this.#state.testHidden = this.#state.testHidden.filter((item) => item !== ref);
+        changed = true;
+      }
+    }
+    if (changed) await this.#save();
+  }
+  async #ensureWorkspace(host, remote) {
+    const ref = key(host.id, remote.workspaceId);
+    const existing = this.#state.workspaces[ref];
+    if (existing !== void 0) {
+      try {
+        await mkdir(existing.anchor, { recursive: true });
+        const workspace2 = await this.#workspaceRegistry.create(existing.anchor, existing.title);
+        existing.localWorkspaceId = String(workspace2.id);
+        if (existing.remoteRoot === void 0) {
+          this.#state.workspaces[ref] = { ...existing, remoteRoot: remote.path };
+          await this.#save();
+        }
+        return workspace2;
+      } catch (error) {
+        this.#ctx.logger.warn("dsh-remote-local: mapped workspace %s unavailable: %s", ref, String(error));
+      }
+    }
+    const anchor = join3(this.#config.stateDir, "anchors", safe(host.id), safe(remote.workspaceId));
+    await mkdir(anchor, { recursive: true });
+    const title = `${host.label} \xB7 ${remote.title}`;
+    const workspace = await this.#workspaceRegistry.create(anchor, title);
+    this.#state.workspaces[ref] = {
+      hostId: host.id,
+      remoteWorkspaceId: remote.workspaceId,
+      localWorkspaceId: String(workspace.id),
+      anchor,
+      remoteRoot: remote.path,
+      title,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.#save();
+    return workspace;
+  }
+  async #ensureUngroupedWorkspace(host, cwd) {
+    const remoteId = `ungrouped:${createHash("sha1").update(cwd).digest("hex").slice(0, 12)}`;
+    const ref = key(host.id, remoteId);
+    const existing = this.#state.workspaces[ref];
+    if (existing !== void 0) {
+      await mkdir(existing.anchor, { recursive: true });
+      const workspace2 = await this.#workspaceRegistry.create(existing.anchor, existing.title);
+      existing.localWorkspaceId = String(workspace2.id);
+      if (existing.remoteRoot === void 0) {
+        this.#state.workspaces[ref] = { ...existing, remoteRoot: cwd };
+        await this.#save();
+      }
+      return { workspace: workspace2, anchor: existing.anchor };
+    }
+    const anchor = join3(this.#config.stateDir, "anchors", safe(host.id), "ungrouped", remoteId.split(":")[1] ?? "root");
+    await mkdir(anchor, { recursive: true });
+    const title = `${host.label} \xB7 ${cwd}`;
+    const workspace = await this.#workspaceRegistry.create(anchor, title);
+    this.#state.workspaces[ref] = {
+      hostId: host.id,
+      remoteWorkspaceId: null,
+      localWorkspaceId: String(workspace.id),
+      anchor,
+      remoteRoot: cwd,
+      title,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.#save();
+    return { workspace, anchor };
+  }
+  #ensureApprovalStream(host) {
+    if (this.#approvalStreams.has(host.id)) return;
+    const controller = new AbortController();
+    this.#approvalStreams.set(host.id, controller);
+    void (async () => {
+      try {
+        for await (const frame of this.#hosts.followApprovals(host.id, controller.signal)) {
+          if (frame.type === "request") void this.#handleApproval(host.id, frame.request);
+        }
+      } catch (error) {
+        if (!controller.signal.aborted) {
+          this.#ctx.logger.warn("dsh-remote-local: approval stream %s failed: %s", host.id, String(error));
+        }
+      } finally {
+        this.#approvalStreams.delete(host.id);
+      }
+    })();
+  }
+  async #handleApproval(hostId, request) {
+    const runtime = [...this.#runtimes.values()].find(
+      (item) => item.record.hostId === hostId && item.record.remoteSessionId === request.sessionId
+    );
+    if (runtime === void 0) {
+      await this.#hosts.answerApproval(hostId, request.id, "unavailable").catch(() => void 0);
+      return;
+    }
+    const local = new AbortController();
+    let outcome = "unavailable";
+    try {
+      const waterfall = this.#ctx.waterfall;
+      outcome = await waterfall(
+        scopeTarget(runtime.agent, runtime.agent),
+        "approval/request",
+        {
+          agent: runtime.agent,
+          toolName: request.toolName,
+          ...request.callId === void 0 ? {} : { callId: request.callId },
+          ...request.reason === void 0 ? {} : { reason: request.reason },
+          ...request.displayReason === void 0 ? {} : { displayReason: request.displayReason },
+          signal: local.signal
+        },
+        async () => "unavailable"
+      );
+    } catch (error) {
+      this.#ctx.logger.warn("dsh-remote-local: local approval bridge failed: %s", String(error));
+      outcome = "unavailable";
+    }
+    await this.#hosts.answerApproval(hostId, request.id, outcome).catch((error) => {
+      this.#ctx.logger.warn("dsh-remote-local: approval answer failed: %s", String(error));
+    });
+  }
+  async #ensureMirror(host, remote, workspace, _remotePath) {
+    const ref = key(host.id, remote.sessionId);
+    const existing = this.#state.sessions[ref];
+    if (existing !== void 0) {
+      const live = this.#sessions.get(existing.localSessionId);
+      const runtime2 = this.#runtimes.get(existing.localSessionId);
+      if (live !== void 0 && runtime2 !== void 0) {
+        await this.#attach(workspace, live.id);
+        return existing;
+      }
+      if (live !== void 0) {
+        await this.#archive(existing.localSessionId);
+      } else if (existing.localSessionId !== "") {
+        await this.#archive(existing.localSessionId);
+      }
+    }
+    const snapshot = await this.#hosts.snapshot(host.id, remote.sessionId, this.#config.mirrorMaxEvents);
+    if (snapshot.truncated && (snapshot.events[0]?.seq ?? 0) > 0) {
+      this.#ctx.logger.warn(
+        "dsh-remote-local: remote session %s is too long to mirror (%d events); open it in the remote UI",
+        remote.sessionId,
+        snapshot.cursor
+      );
+      return void 0;
+    }
+    const anchor = this.#anchorFor(workspace);
+    await mkdir(anchor, { recursive: true });
+    const localId = `session-${randomUUID()}`;
+    let session;
+    try {
+      const filtered = snapshot.events.filter((event) => !isMirrorNoise(event.type));
+      const seqMap = new Map(filtered.map((event, index) => [event.seq, index]));
+      const seed = filtered.map((event, index) => toSeedEvent(event, index, seqMap));
+      session = this.#sessions.create(localId, {
+        ...seed.length === 0 ? {} : { seed },
+        meta: { cwd: anchor }
+      });
+    } catch (error) {
+      this.#ctx.logger.warn("dsh-remote-local: could not seed mirror for %s: %s", remote.sessionId, String(error));
+      return void 0;
+    }
+    await this.#attach(workspace, session.id);
+    try {
+      await this.#sessions.flush(session);
+    } catch (error) {
+      this.#ctx.logger.debug("dsh-remote-local: mirror flush failed: %s", String(error));
+    }
+    const record = {
+      hostId: host.id,
+      remoteSessionId: remote.sessionId,
+      localSessionId: localId,
+      remoteWorkspaceId: remote.workspaceId,
+      anchor,
+      lastSeq: snapshot.cursor,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.#state.sessions[ref] = record;
+    const runtime = {
+      record,
+      agent: null,
+      session,
+      timer: void 0,
+      running: false,
+      stopped: false,
+      lastError: null,
+      pendingUsers: [],
+      waiters: []
+    };
+    const options = modelOptions(snapshot.events);
+    const agent = new RemoteMirrorAgent(this, runtime, this.#ctx, options);
+    runtime.agent = agent;
+    this.#runtimes.set(localId, runtime);
+    this.#registrations.set(localId, this.#agents.enter(agent, void 0));
+    await this.#save();
+    this.#schedule(runtime);
+    this.#ctx.logger.info(
+      "dsh-remote-local: mirrored remote session %s as local %s",
+      remote.sessionId,
+      localId
+    );
+    return record;
+  }
+  #schedule(runtime) {
+    if (runtime.stopped || this.#disposed) return;
+    runtime.timer = setTimeout(() => {
+      void this.#poll(runtime);
+    }, Math.max(500, this.#config.mirrorPollMs));
+  }
+  async #poll(runtime) {
+    if (runtime.stopped || this.#disposed) return;
+    try {
+      const local = this.#sessions.get(runtime.session.id);
+      if (local === void 0) {
+        runtime.stopped = true;
+        return;
+      }
+      const snapshot = await this.#hosts.snapshot(
+        runtime.record.hostId,
+        runtime.record.remoteSessionId,
+        this.#config.mirrorMaxEvents
+      );
+      if (snapshot.truncated && (snapshot.events[0]?.seq ?? 0) > runtime.record.lastSeq) {
+        runtime.lastError = "remote log grew past the mirror window";
+        runtime.stopped = true;
+        return;
+      }
+      let sawEnd = false;
+      for (const event of snapshot.events) {
+        if (event.seq < runtime.record.lastSeq) continue;
+        if (event.seq !== runtime.record.lastSeq) {
+          throw new Error(`remote event gap at ${event.seq}, mirror ${runtime.record.lastSeq}`);
+        }
+        if (!isMirrorNoise(event.type)) appendRemoteEvent(local, event, runtime);
+        runtime.record.lastSeq = event.seq + 1;
+        if (event.type === "turn/end") sawEnd = true;
+      }
+      runtime.record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (sawEnd) this.#setRunning(runtime, false);
+      if (!snapshot.live && runtime.record.lastSeq >= snapshot.cursor) {
+        runtime.stopped = true;
+      }
+      await this.#save();
+    } catch (error) {
+      runtime.lastError = error instanceof Error ? error.message : String(error);
+      this.#ctx.logger.warn(
+        "dsh-remote-local: mirror poll %s failed: %s",
+        runtime.record.remoteSessionId,
+        runtime.lastError
+      );
+    }
+    this.#schedule(runtime);
+  }
+  #setRunning(runtime, running) {
+    if (runtime.running === running) return;
+    runtime.running = running;
+    if (!running) {
+      for (const waiter of runtime.waiters.splice(0)) waiter();
+    }
+  }
+  async #attach(workspace, sessionId) {
+    try {
+      await workspace.attachSession(sessionId);
+    } catch (error) {
+      this.#ctx.logger.debug("dsh-remote-local: attach mirror %s failed: %s", sessionId, String(error));
+    }
+  }
+  async #archive(sessionId) {
+    try {
+      await this.#workspaceRegistry.archiveSession(sessionId, { stopActivity: true });
+    } catch {
+    }
+  }
+  #anchorFor(workspace) {
+    for (const record of Object.values(this.#state.workspaces)) {
+      if (record.localWorkspaceId === String(workspace.id)) return record.anchor;
+    }
+    return join3(this.#config.stateDir, "anchors", safe(String(workspace.id)));
+  }
+  async #load() {
+    try {
+      const raw = await readFile2(join3(this.#config.stateDir, "mirrors.json"), "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed.version === MIRROR_VERSION && parsed.sessions !== void 0 && parsed.workspaces !== void 0) {
+        this.#state = {
+          version: MIRROR_VERSION,
+          sessions: parsed.sessions,
+          workspaces: parsed.workspaces,
+          testHidden: Array.isArray(parsed.testHidden) ? parsed.testHidden : []
+        };
+      }
+    } catch {
+    }
+  }
+  async #save() {
+    const snapshot = `${JSON.stringify(this.#state, null, 2)}
+`;
+    const task = this.#saveQueue.then(async () => {
+      await mkdir(this.#config.stateDir, { recursive: true });
+      const path = join3(this.#config.stateDir, "mirrors.json");
+      const temp = `${path}.${randomUUID()}.tmp`;
+      await writeFile(temp, snapshot, { mode: 384 });
+      await rename(temp, path);
+    });
+    this.#saveQueue = task.then(() => void 0, () => void 0);
+    return task;
+  }
+};
+function isMirrorNoise(type) {
+  return type === "agent/inbox/spliced";
+}
+function appendRemoteEvent(session, event, runtime) {
+  if (event.type === "user/message" && runtime.pendingUsers.length > 0) {
+    const source = event.data.source;
+    if (source?.kind === "user") {
+      const message = runtime.pendingUsers.shift();
+      if (message !== void 0) {
+        session.append("user/message", messageData(message), { surfaceOp: "append" });
+        return;
+      }
+    }
+  }
+  const append = session.append.bind(session);
+  if (SURFACE_TYPES.has(event.type)) {
+    const opts = {
+      surfaceOp: event.surfaceOp ?? "append",
+      ...event.sourceEventSeqs === void 0 ? {} : { sourceEventSeqs: event.sourceEventSeqs }
+    };
+    append(event.type, event.data, opts);
+  } else {
+    append(event.type, event.data);
+  }
+}
+function messageData(message) {
+  if (typeof message !== "object" || message === null) return message;
+  const record = message;
+  return {
+    ...typeof record.id === "string" ? { id: record.id } : { id: `msg-${randomUUID()}` },
+    role: "user",
+    content: Array.isArray(record.content) ? record.content : [],
+    source: record.source ?? { kind: "user" }
+  };
+}
+function toSeedEvent(event, seq, map) {
+  const surfaceOp = typeof event.surfaceOp === "object" ? {
+    op: "replace",
+    startSeq: map.get(event.surfaceOp.startSeq) ?? 0,
+    endSeq: map.get(event.surfaceOp.endSeq) ?? 0
+  } : event.surfaceOp;
+  const sourceEventSeqs = event.sourceEventSeqs?.map((source) => map.get(source)).filter((source) => source !== void 0);
+  return {
+    seq,
+    type: event.type,
+    time: event.time,
+    data: event.data,
+    ...surfaceOp === void 0 ? {} : { surfaceOp },
+    ...sourceEventSeqs === void 0 || sourceEventSeqs.length === 0 ? {} : { sourceEventSeqs }
+  };
+}
+function modelOptions(events) {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index];
+    if (event?.type !== "request/header") continue;
+    const data = event.data;
+    if (typeof data.config?.provider === "string" && typeof data.config.model === "string") {
+      return {
+        provider: data.config.provider,
+        model: data.config.model,
+        ...typeof data.config.reasoningEffort === "string" ? { reasoningEffort: data.config.reasoningEffort } : {}
+      };
+    }
+  }
+  return { provider: "deepseek-official", model: "deepseek-flash" };
+}
+function latestSelection(session) {
+  const events = session.snapshotEvents();
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index];
+    const record = event;
+    if (record.type !== "model/selection") continue;
+    const data = record.data ?? {};
+    if (typeof data.provider === "string" && typeof data.model === "string") {
+      return {
+        provider: data.provider,
+        model: data.model,
+        ...typeof data.reasoningEffort === "string" ? { reasoningEffort: data.reasoningEffort } : {}
+      };
+    }
+  }
+  return void 0;
+}
+function contentText(message) {
+  if (typeof message === "string") return message;
+  if (typeof message !== "object" || message === null) return "";
+  const content = message.content;
+  if (!Array.isArray(content)) return "";
+  const texts = [];
+  for (const part of content) {
+    if (typeof part === "string") texts.push(part);
+    else if (typeof part === "object" && part !== null && part.type === "text") {
+      const text = part.text;
+      if (typeof text === "string") texts.push(text);
+    }
+  }
+  return texts.join("\n").trim();
+}
+function canonicalPath(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+function key(hostId, sessionId) {
+  return `${hostId}:${sessionId}`;
+}
+function safe(value) {
+  return createHash("sha1").update(value).digest("hex").slice(0, 16);
+}
+
+// src/remote/files.ts
+import { spawn as spawn2 } from "node:child_process";
+import { isAbsolute as isAbsolute2, join as join4, relative, resolve as resolve3, sep } from "node:path";
+var HELPER = String.raw`
+import sys, json, os, base64
+req = json.load(sys.stdin)
+action = req.get('action')
+path = req.get('path')
+def stat_payload(st):
+    return {'absolutePath': path, 'version': f'{st.st_mtime_ns}:{st.st_size}', 'bytes': st.st_size}
+try:
+    if action == 'stat':
+        st = os.stat(path)
+        if not os.path.isfile(path):
+            raise IsADirectoryError(path)
+        print(json.dumps(stat_payload(st)))
+    elif action == 'read':
+        st = os.stat(path)
+        if not os.path.isfile(path):
+            raise IsADirectoryError(path)
+        offset = max(1, int(req.get('offset', 1)))
+        limit = max(1, min(int(req.get('limit', 200)), 2000))
+        max_line = 32 * 1024
+        max_page = 1024 * 1024
+        page = []
+        page_bytes = 0
+        saw_more = False
+        with open(path, 'rb') as handle:
+            index = 0
+            while True:
+                line = handle.readline(max_line + 1)
+                if not line:
+                    break
+                index += 1
+                if index < offset:
+                    if len(line) > max_line and not line.endswith(b'\n'):
+                        while True:
+                            rest = handle.readline(64 * 1024)
+                            if not rest or rest.endswith(b'\n'):
+                                break
+                    continue
+                if len(page) >= limit or page_bytes + len(line) > max_page:
+                    saw_more = True
+                    break
+                truncated = len(line) > max_line
+                if truncated and not line.endswith(b'\n'):
+                    while True:
+                        rest = handle.readline(64 * 1024)
+                        if not rest or rest.endswith(b'\n'):
+                            break
+                if truncated:
+                    line = line[:max_line]
+                text = line.rstrip(b'\r\n').decode('utf-8', errors='replace' if truncated else 'strict')
+                if truncated:
+                    text += '… [line truncated]'
+                page.append(text)
+                page_bytes += len(line)
+                if len(page) >= limit:
+                    if handle.read(1):
+                        saw_more = True
+                    break
+        eof = not saw_more
+        text = '\n'.join(page)
+        if '\x00' in text:
+            raise ValueError('NUL')
+        out = stat_payload(st)
+        out.update({'offset': offset, 'lines': len(page), 'text': text, 'eof': eof})
+        print(json.dumps(out))
+    elif action == 'list':
+        entries = []
+        with os.scandir(path) as it:
+            for entry in it:
+                try:
+                    st = entry.stat(follow_symlinks=True)
+                    kind = 'directory' if entry.is_dir(follow_symlinks=True) else ('file' if entry.is_file(follow_symlinks=True) else 'other')
+                    size = st.st_size if kind == 'file' else None
+                except OSError:
+                    kind = 'other'
+                    size = None
+                item = {'name': entry.name, 'type': kind}
+                if size is not None:
+                    item['size'] = size
+                entries.append(item)
+        entries.sort(key=lambda item: item['name'])
+        print(json.dumps({'path': req.get('relative', ''), 'entries': entries, 'truncated': len(entries) > 2000}))
+    elif action == 'bytes':
+        st = os.stat(path)
+        offset = max(0, int(req.get('offset', 0)))
+        length = max(0, min(int(req.get('length', 5_000_000)), 5_000_000))
+        with open(path, 'rb') as handle:
+            handle.seek(offset)
+            window = handle.read(length)
+        print(json.dumps({**stat_payload(st), 'offset': offset, 'data': base64.b64encode(window).decode('ascii'), 'eof': offset + len(window) >= st.st_size}))
+    else:
+        raise ValueError('unknown action')
+except FileNotFoundError:
+    print(json.dumps({'error': {'code': 'workspace-file/not-found', 'message': f'not found: {path}'}}))
+except IsADirectoryError:
+    print(json.dumps({'error': {'code': 'workspace-file/not-regular-file', 'message': f'not a regular file: {path}'}}))
+except UnicodeDecodeError:
+    print(json.dumps({'error': {'code': 'workspace-file/not-text', 'message': f'not UTF-8 text: {path}'}}))
+except Exception as error:
+    print(json.dumps({'error': {'code': 'workspace-file/read-failed', 'message': str(error)}}))
+`;
+function installRemoteWorkspaceFiles(ctx, mirrors, hosts) {
+  const service = ctx.get("workspaceFiles");
+  if (service === void 0) return;
+  const originalRead = service.read.bind(service);
+  const originalReadBytes = service.readBytes.bind(service);
+  const originalStat = service.stat.bind(service);
+  const originalList = service.list.bind(service);
+  const originalChanges = service.changes.bind(service);
+  service.read = async (scope, path, range, signal) => {
+    const target = targetOf(mirrors, scope.workspaceRoot, path);
+    if (target === void 0) return originalRead(scope, path, range, signal);
+    const result = await helper(hosts, target.hostId, {
+      action: "read",
+      path: target.remotePath,
+      offset: range.offset ?? 1,
+      limit: range.limit ?? 200
+    }, signal);
+    return { ...result, absolutePath: target.localPath };
+  };
+  service.readBytes = async (scope, path, options, signal) => {
+    const target = targetOf(mirrors, scope.workspaceRoot, path);
+    if (target === void 0) return originalReadBytes(scope, path, options, signal);
+    const result = await helper(hosts, target.hostId, {
+      action: "bytes",
+      path: target.remotePath,
+      offset: options.range?.offset ?? 0,
+      length: options.range?.length ?? 5e6
+    }, signal);
+    const bytes = Buffer.from(result.data, "base64");
+    return { ...result, absolutePath: target.localPath, data: bytes };
+  };
+  service.stat = async (scope, path, signal) => {
+    const target = targetOf(mirrors, scope.workspaceRoot, path);
+    if (target === void 0) return originalStat(scope, path, signal);
+    const result = await helper(hosts, target.hostId, { action: "stat", path: target.remotePath }, signal);
+    return { ...result, absolutePath: target.localPath };
+  };
+  service.list = async (scope, path, signal) => {
+    const target = targetOf(mirrors, scope.workspaceRoot, path);
+    if (target === void 0) return originalList(scope, path, signal);
+    const result = await helper(hosts, target.hostId, {
+      action: "list",
+      path: target.remotePath,
+      relative: target.relativePath
+    }, signal);
+    return { ...result, path: target.relativePath, entries: result.entries.slice(0, 2e3) };
+  };
+  service.changes = (scope, path, signal) => {
+    const target = targetOf(mirrors, scope.workspaceRoot, path);
+    if (target === void 0) return originalChanges(scope, path, signal);
+    return watch(hosts, target, signal);
+  };
+}
+function targetOf(mirrors, workspaceRoot, path) {
+  const context = mirrors.remoteFileContext(workspaceRoot);
+  if (context === void 0) return void 0;
+  const localPath = isAbsolute2(path) ? resolve3(path) : resolve3(workspaceRoot, path);
+  const rel = relative(workspaceRoot, localPath);
+  if (rel === "" || !rel.startsWith("..") && !isAbsolute2(rel)) {
+    const remotePath = rel === "" ? context.remoteRoot : join4(context.remoteRoot, rel);
+    return {
+      hostId: context.hostId,
+      localPath: localPath === "" ? workspaceRoot : localPath,
+      remotePath,
+      relativePath: rel.split(sep).join("/"),
+      workspaceRoot
+    };
+  }
+  return void 0;
+}
+async function helper(hosts, hostId, request, signal) {
+  const ssh = hosts.sshFor(hostId);
+  const args = [
+    "-o",
+    "BatchMode=yes",
+    "-o",
+    "ConnectTimeout=10000",
+    ...ssh.port === null ? [] : ["-p", String(ssh.port)],
+    ssh.target,
+    "python3",
+    "-c",
+    `'import base64;exec(base64.b64decode("${Buffer.from(HELPER).toString("base64")}"))'`
+  ];
+  const result = await new Promise((resolvePromise, reject) => {
+    const child = spawn2(ssh.binary, args, { stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error("remote file helper timed out"));
+    }, 3e4);
+    const abort = () => {
+      child.kill("SIGKILL");
+      reject(new Error("remote file helper aborted"));
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", abort);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", abort);
+      if (code !== 0) reject(new Error(stderr.trim() || `remote file helper exited ${String(code)}`));
+      else resolvePromise(stdout);
+    });
+    child.stdin.end(JSON.stringify(request));
+  });
+  const line = result.trim().split("\n").at(-1) ?? "";
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    throw new Error("remote file helper returned invalid JSON");
+  }
+  if ("error" in parsed) {
+    const failure = parsed;
+    throw Object.assign(new Error(failure.error.message), { code: failure.error.code });
+  }
+  return parsed;
+}
+async function* watch(hosts, target, signal) {
+  yield { kind: "ready" };
+  let last = "";
+  while (!signal.aborted) {
+    try {
+      const stat2 = await helper(hosts, target.hostId, { action: "stat", path: target.remotePath }, signal);
+      if (stat2.version !== last) {
+        last = stat2.version;
+        yield { kind: "change", change: { absolutePath: target.localPath, version: stat2.version } };
+      }
+    } catch {
+      try {
+        const listing = await helper(hosts, target.hostId, {
+          action: "list",
+          path: target.remotePath,
+          relative: target.relativePath
+        }, signal);
+        const version = `${listing.entries.length}:${listing.entries.map((entry) => `${entry.name}:${entry.size ?? ""}`).join(",")}`;
+        if (version !== last) {
+          last = version;
+          yield { kind: "change", change: { absolutePath: target.localPath, version } };
+        }
+      } catch {
+      }
+    }
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, 2e3));
+  }
+}
+
+// src/remote/terminal.ts
+import { spawn as spawn3 } from "node:child_process";
+import { randomUUID as randomUUID2 } from "node:crypto";
+var MAX_BUFFERED_BYTES = 512 * 1024;
+var RemoteTerminals = class {
+  #ctx;
+  #hosts;
+  #mirrors;
+  #terminals = /* @__PURE__ */ new Map();
+  constructor(ctx, hosts, mirrors) {
+    this.#ctx = ctx;
+    this.#hosts = hosts;
+    this.#mirrors = mirrors;
+  }
+  /** Whether this Session owns a mirrored workspace. */
+  isMirrored(sessionId) {
+    return this.#context(sessionId) !== void 0;
+  }
+  /** Return the remote cwd/limits for one Session. */
+  environment(sessionId) {
+    const context = this.#context(sessionId);
+    return {
+      cwd: context?.remoteRoot ?? "/",
+      maxInputBytes: 64 * 1024,
+      maxBufferedBytes: MAX_BUFFERED_BYTES,
+      maxCols: 240,
+      maxRows: 80,
+      scrollback: 4e3
+    };
+  }
+  /** One remote shell candidate. */
+  shells() {
+    return [{ path: "ssh", name: "Remote SSH", args: [] }];
+  }
+  /** Terminals retained for one Session. */
+  list(sessionId) {
+    return [...this.#terminals.values()].filter((item) => item.sessionId === sessionId).map((item) => item.info);
+  }
+  /** Allocate an SSH PTY in the mirrored workspace. */
+  create(sessionId, request) {
+    const context = this.#context(sessionId);
+    if (context === void 0) throw new Error("terminal is only available for mirrored sessions");
+    const id = request.id ?? randomUUID2();
+    const existing = this.#terminals.get(id);
+    if (existing !== void 0) return existing.info;
+    const ssh = this.#hosts.sshFor(context.hostId);
+    const cwd = shellQuote(context.remoteRoot);
+    const args = [
+      "-tt",
+      "-o",
+      "BatchMode=yes",
+      "-o",
+      "ConnectTimeout=10000",
+      ...ssh.port === null ? [] : ["-p", String(ssh.port)],
+      ssh.target,
+      `cd ${cwd} && exec bash -l`
+    ];
+    const child = spawn3(ssh.binary, args, { stdio: ["pipe", "pipe", "pipe"] });
+    const info = {
+      id,
+      title: `Remote \xB7 ${context.remoteRoot.split("/").at(-1) ?? context.remoteRoot}`,
+      shell: { path: "ssh", name: "Remote SSH", args: [] },
+      cwd: context.remoteRoot,
+      cols: request.cols ?? 80,
+      rows: request.rows ?? 24,
+      state: "running",
+      exitCode: null
+    };
+    const runtime = {
+      id,
+      sessionId,
+      info,
+      child,
+      queue: [],
+      waiters: [],
+      sequence: 0,
+      bufferedBytes: 0,
+      title: info.title,
+      exited: false
+    };
+    this.#terminals.set(id, runtime);
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (data) => this.#push(runtime, { type: "output", sequence: ++runtime.sequence, data }));
+    child.stderr.on("data", (data) => this.#push(runtime, { type: "output", sequence: ++runtime.sequence, data }));
+    child.on("exit", (code) => {
+      runtime.exited = true;
+      runtime.info = { ...runtime.info, state: code === 0 ? "exited" : "failed", exitCode: code };
+      this.#push(runtime, { type: "state", info: runtime.info, writable: false });
+      this.#closeWaiters(runtime);
+    });
+    child.on("error", (error) => {
+      runtime.exited = true;
+      runtime.info = { ...runtime.info, state: "failed", error: String(error) };
+      this.#push(runtime, { type: "state", info: runtime.info, writable: false });
+    });
+    return info;
+  }
+  /** Feed input/resize into one remote PTY. */
+  input(id, input) {
+    const runtime = this.#terminals.get(id);
+    if (runtime === void 0 || runtime.exited) return;
+    if (input.type === "write") runtime.child.stdin.write(input.data);
+    else {
+      runtime.child.stdin.write(`stty cols ${input.cols} rows ${input.rows} 2>/dev/null || true
+`);
+    }
+  }
+  /** Rename a retained terminal. */
+  rename(id, title) {
+    const runtime = this.#terminals.get(id);
+    if (runtime !== void 0) runtime.title = title;
+  }
+  /** Close one terminal. */
+  close(id) {
+    const runtime = this.#terminals.get(id);
+    if (runtime === void 0) return;
+    runtime.child.kill("SIGHUP");
+    this.#terminals.delete(id);
+  }
+  /** Stream frames for one attachment. */
+  async *attach(id, signal) {
+    const runtime = this.#terminals.get(id);
+    if (runtime === void 0) throw new Error(`terminal ${id} is unavailable`);
+    yield {
+      type: "snapshot",
+      sequence: runtime.sequence,
+      screen: "",
+      info: runtime.info,
+      writable: !runtime.exited
+    };
+    while (!signal.aborted) {
+      if (signal.aborted) return;
+      if (runtime.queue.length > 0) {
+        const frame = runtime.queue.shift();
+        runtime.bufferedBytes = Math.max(0, runtime.bufferedBytes - frameSize(frame));
+        yield frame;
+        continue;
+      }
+      if (runtime.exited) return;
+      const next = await new Promise((resolve4) => {
+        let settled = false;
+        const finish = (result) => {
+          if (settled) return;
+          settled = true;
+          signal.removeEventListener("abort", onAbort);
+          const index = runtime.waiters.indexOf(finish);
+          if (index >= 0) runtime.waiters.splice(index, 1);
+          resolve4(result);
+        };
+        const onAbort = () => finish({ done: true, value: void 0 });
+        runtime.waiters.push(finish);
+        signal.addEventListener("abort", onAbort, { once: true });
+      });
+      if (next.done) return;
+      yield next.value;
+    }
+  }
+  /** Retain acknowledgement used by reconnecting windows. */
+  async *retain() {
+    yield { type: "retained" };
+  }
+  /** Dispose every process. */
+  dispose() {
+    for (const runtime of this.#terminals.values()) runtime.child.kill("SIGHUP");
+    this.#terminals.clear();
+  }
+  #context(sessionId) {
+    const sessions = this.#ctx.get("sessions");
+    const session = sessions?.get(sessionId);
+    const cwd = session?.header.cwd;
+    if (cwd === void 0) return void 0;
+    return this.#mirrors.remoteFileContext(cwd);
+  }
+  #push(runtime, frame) {
+    const waiter = runtime.waiters.shift();
+    if (waiter !== void 0) {
+      waiter({ done: false, value: frame });
+      return;
+    }
+    let normalized = frame;
+    let bytes = frameSize(frame);
+    if (bytes > MAX_BUFFERED_BYTES) {
+      if (frame.type === "output") {
+        const marker = "\n[dsh-remote: terminal output truncated]\n";
+        const limit = Math.max(0, MAX_BUFFERED_BYTES - Buffer.byteLength(marker));
+        normalized = { ...frame, data: `${frame.data.slice(0, limit)}${marker}` };
+        bytes = frameSize(normalized);
+      } else {
+        runtime.queue.length = 0;
+        runtime.bufferedBytes = 0;
+      }
+    }
+    while (runtime.queue.length > 0 && runtime.bufferedBytes + bytes > MAX_BUFFERED_BYTES) {
+      const dropped = runtime.queue.shift();
+      runtime.bufferedBytes = Math.max(0, runtime.bufferedBytes - frameSize(dropped));
+    }
+    runtime.queue.push(normalized);
+    runtime.bufferedBytes += bytes;
+  }
+  #closeWaiters(runtime) {
+    for (const waiter of runtime.waiters.splice(0)) waiter({ done: true, value: void 0 });
+  }
+};
+function frameSize(frame) {
+  return Buffer.byteLength(JSON.stringify(frame));
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/gu, `'\\''`)}'`;
+}
+
+// src/host-api/terminal.ts
+var TERMINAL_API_PATH = "/api/dsh-remote-terminal";
+function registerTerminalApi(ctx, terminals) {
+  return ctx.connection.fetch.register({
+    path: TERMINAL_API_PATH,
+    methods: ["POST"],
+    requestBody: "buffered",
+    fetch: async (request) => {
+      let body;
+      try {
+        body = await request.json();
+      } catch {
+        return Response.json({ ok: false, error: { code: "request/invalid", message: "body must be JSON" } });
+      }
+      try {
+        const action = String(body.action ?? "");
+        const sessionId = String(body.sessionId ?? "");
+        if (action === "context") return Response.json({ ok: true, mirrored: terminals.isMirrored(sessionId) });
+        if (action === "environment") return Response.json({ ok: true, value: terminals.environment(sessionId) });
+        if (action === "shells") return Response.json({ ok: true, value: terminals.shells() });
+        if (action === "list") return Response.json({ ok: true, value: terminals.list(sessionId) });
+        if (action === "create") {
+          return Response.json({
+            ok: true,
+            value: terminals.create(sessionId, {
+              ...typeof body.id === "string" ? { id: body.id } : {},
+              ...typeof body.cols === "number" ? { cols: body.cols } : {},
+              ...typeof body.rows === "number" ? { rows: body.rows } : {}
+            })
+          });
+        }
+        const id = String(body.id ?? "");
+        if (action === "input") {
+          terminals.input(id, { type: "write", sequence: Number(body.sequence ?? 0), data: String(body.data ?? "") });
+          return Response.json({ ok: true, value: null });
+        }
+        if (action === "resize") {
+          terminals.input(id, { type: "resize", sequence: Number(body.sequence ?? 0), cols: Number(body.cols ?? 80), rows: Number(body.rows ?? 24) });
+          return Response.json({ ok: true, value: null });
+        }
+        if (action === "rename") {
+          terminals.rename(id, String(body.title ?? ""));
+          return Response.json({ ok: true, value: null });
+        }
+        if (action === "close") {
+          terminals.close(id);
+          return Response.json({ ok: true, value: null });
+        }
+        if (action === "retain") {
+          return new Response(sse([{ type: "retained" }].map((frame) => `event: frame
+data: ${JSON.stringify(frame)}
+
+`).join("")), {
+            headers: { "content-type": "text/event-stream; charset=utf-8", "cache-control": "no-cache" }
+          });
+        }
+        if (action === "attach") {
+          const signal = request.signal;
+          const stream = new ReadableStream({
+            async start(controller) {
+              const encoder = new TextEncoder();
+              try {
+                for await (const frame of terminals.attach(id, signal)) {
+                  controller.enqueue(encoder.encode(`event: frame
+data: ${JSON.stringify(frame)}
+
+`));
+                }
+              } catch (error) {
+                controller.enqueue(encoder.encode(`event: error
+data: ${JSON.stringify({ message: String(error) })}
+
+`));
+              } finally {
+                controller.close();
+              }
+            }
+          });
+          return new Response(stream, {
+            headers: {
+              "content-type": "text/event-stream; charset=utf-8",
+              "cache-control": "no-cache, no-transform",
+              connection: "keep-alive",
+              "x-accel-buffering": "no"
+            }
+          });
+        }
+        return Response.json({ ok: false, error: { code: "request/invalid", message: `unknown terminal action ${action}` } });
+      } catch (error) {
+        return Response.json({ ok: false, error: { code: "terminal/error", message: error instanceof Error ? error.message : String(error) } });
+      }
+    }
+  });
+}
+function sse(value) {
+  return value;
+}
+
+// src/service.ts
+import { createHash as createHash3, randomBytes, timingSafeEqual } from "node:crypto";
+
+// ../protocol/lib/version.js
+var PROTOCOL_VERSION = 1;
+var MIN_SUPPORTED_PROTOCOL_VERSION = 1;
+var MAX_SUPPORTED_PROTOCOL_VERSION = 1;
+var AGENT_API_PREFIX = "/dsh-remote-agent/api/v1";
+var HEADER_PROTOCOL_VERSION = "x-dsh-remote-protocol";
+var HEADER_SERVER_PROTOCOL_VERSION = "x-dsh-remote-server-protocol";
+var HEADER_HOST_ID = "x-dsh-remote-host-id";
+var DEFAULT_REQUEST_TIMEOUT_MS = 15e3;
+var MAX_CONTROL_BODY_BYTES = 64 * 1024;
+function isProtocolSupported(version) {
+  return Number.isInteger(version) && version >= MIN_SUPPORTED_PROTOCOL_VERSION && version <= MAX_SUPPORTED_PROTOCOL_VERSION;
+}
+
+// ../protocol/lib/discovery.js
+var DISCOVERY_STATE_VERSION = 1;
+function isAgentDiscoveryState(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const record = value;
+  return record.version === DISCOVERY_STATE_VERSION && typeof record.token === "string" && record.token.length >= 16 && (record.port === null || typeof record.port === "number" && Number.isInteger(record.port) && record.port > 0) && typeof record.pid === "number" && typeof record.startedAt === "string" && typeof record.updatedAt === "string" && typeof record.agentVersion === "string" && typeof record.dshVersion === "string" && (record.url === null || typeof record.url === "string") && (record.stoppedAt === void 0 || typeof record.stoppedAt === "string");
+}
+function isAgentLive(state) {
+  return state.port !== null && state.stoppedAt === void 0;
+}
+
+// ../protocol/lib/errors.js
+function httpStatusForCode(code) {
+  switch (code) {
+    case "protocol/version-mismatch":
+      return 409;
+    case "auth/missing":
+    case "auth/invalid":
+      return 401;
+    case "auth/forbidden":
+      return 403;
+    case "request/invalid":
+      return 400;
+    case "request/too-large":
+      return 413;
+    case "route/not-found":
+    case "workspace/not-found":
+    case "session/not-found":
+      return 404;
+    case "session/not-live":
+      return 409;
+    case "agent/not-ready":
+      return 503;
+    case "internal":
+      return 500;
+  }
+}
+function isRetryableCode(code) {
+  return code === "agent/not-ready" || code === "internal";
+}
+var RemoteProtocolError = class extends Error {
+  code;
+  retryable;
+  details;
+  httpStatus;
+  constructor(init) {
+    super(init.message, init.cause === void 0 ? void 0 : { cause: init.cause });
+    this.name = "RemoteProtocolError";
+    this.code = init.code;
+    this.retryable = init.retryable ?? isRetryableCode(init.code);
+    this.details = init.details;
+    this.httpStatus = init.httpStatus ?? httpStatusForCode(init.code);
+  }
+  /** JSON-safe failure body. */
+  toFailure() {
+    return {
+      code: this.code,
+      message: this.message,
+      retryable: this.retryable,
+      ...this.details === void 0 ? {} : { details: this.details }
+    };
+  }
+};
+
+// ../protocol/lib/routes.js
+var AGENT_ROUTES = {
+  health: `${AGENT_API_PREFIX}/health`,
+  host: `${AGENT_API_PREFIX}/host`,
+  workspaces: `${AGENT_API_PREFIX}/workspaces`,
+  sessions: `${AGENT_API_PREFIX}/sessions`,
+  webUrl: `${AGENT_API_PREFIX}/web-url`,
+  approvalEvents: `${AGENT_API_PREFIX}/approvals/events`,
+  approvalAnswer: `${AGENT_API_PREFIX}/approvals/answer`
+};
+function workspaceSessionsPath(workspaceId) {
+  return `${AGENT_API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/sessions`;
+}
+function sessionPath(sessionId) {
+  return `${AGENT_API_PREFIX}/sessions/${encodeURIComponent(sessionId)}`;
+}
+function sessionPromptPath(sessionId) {
+  return `${sessionPath(sessionId)}/prompt`;
+}
+function sessionCancelPath(sessionId) {
+  return `${sessionPath(sessionId)}/cancel`;
+}
+function sessionEventsPath(sessionId, cursor) {
+  const base = `${sessionPath(sessionId)}/events`;
+  return cursor === void 0 ? base : `${base}?cursor=${encodeURIComponent(String(cursor))}`;
+}
+var SESSION_PREFIX = `${AGENT_API_PREFIX}/sessions/`;
+var WORKSPACE_PREFIX = `${AGENT_API_PREFIX}/workspaces/`;
+
+// ../protocol/lib/sse.js
+async function* parseSseStream(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let eventName = "";
+  let dataLines = [];
+  let id;
+  const dispatch2 = () => {
+    if (dataLines.length === 0 && eventName === "" && id === void 0)
+      return void 0;
+    const message = {
+      event: eventName === "" ? "message" : eventName,
+      data: dataLines.join("\n"),
+      id
+    };
+    eventName = "";
+    dataLines = [];
+    id = void 0;
+    return message;
+  };
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) {
+        buffer += decoder.decode();
+      } else {
+        buffer += decoder.decode(value, { stream: true });
+      }
+      let newline = buffer.indexOf("\n");
+      while (newline >= 0) {
+        let line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        if (line.endsWith("\r"))
+          line = line.slice(0, -1);
+        if (line === "") {
+          const message = dispatch2();
+          if (message !== void 0)
+            yield message;
+        } else if (line.startsWith(":")) {
+        } else {
+          const colon = line.indexOf(":");
+          const field = colon < 0 ? line : line.slice(0, colon);
+          let fieldValue = colon < 0 ? "" : line.slice(colon + 1);
+          if (fieldValue.startsWith(" "))
+            fieldValue = fieldValue.slice(1);
+          switch (field) {
+            case "event":
+              eventName = fieldValue;
+              break;
+            case "data":
+              dataLines.push(fieldValue);
+              break;
+            case "id":
+              id = fieldValue;
+              break;
+            default:
+              break;
+          }
+        }
+        newline = buffer.indexOf("\n");
+      }
+      if (done) {
+        if (buffer !== "") {
+          const line = buffer.endsWith("\r") ? buffer.slice(0, -1) : buffer;
+          buffer = "";
+          if (line.startsWith("data:"))
+            dataLines.push(line.slice(5).replace(/^ /, ""));
+          else if (line.startsWith("event:"))
+            eventName = line.slice(6).replace(/^ /, "");
+          else if (line.startsWith("id:"))
+            id = line.slice(3).replace(/^ /, "");
+        }
+        const message = dispatch2();
+        if (message !== void 0)
+          yield message;
+        return;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// ../protocol/lib/validation.js
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every(isString);
+}
+function isIsoString(value) {
+  return isString(value) && !Number.isNaN(Date.parse(value));
+}
+function isHostInfo(value) {
+  if (!isRecord(value))
+    return false;
+  return isString(value.hostId) && isString(value.hostname) && isString(value.platform) && isString(value.arch) && isString(value.dshVersion) && isString(value.agentVersion) && isString(value.home) && isIsoString(value.startedAt) && typeof value.protocolVersion === "number" && Array.isArray(value.capabilities) && value.capabilities.every(isString) && typeof value.workspaceCount === "number" && (value.modelBaseUrl === void 0 || value.modelBaseUrl === null || isString(value.modelBaseUrl)) && (value.modelKeyConfigured === void 0 || typeof value.modelKeyConfigured === "boolean") && (value.modelKeyFingerprint === void 0 || value.modelKeyFingerprint === null || isString(value.modelKeyFingerprint));
+}
+function isApprovalRequest(value) {
+  if (!isRecord(value))
+    return false;
+  return isString(value.id) && isString(value.sessionId) && isString(value.toolName) && (value.callId === void 0 || isString(value.callId)) && (value.reason === void 0 || isString(value.reason)) && (value.displayReason === void 0 || isRecord(value.displayReason) && Object.values(value.displayReason).every(isString));
+}
+function isRemoteApprovalFrame(value) {
+  if (!isRecord(value))
+    return false;
+  if (value.type === "ready")
+    return true;
+  return value.type === "request" && isApprovalRequest(value.request);
+}
+function isRemoteWorkspace(value) {
+  if (!isRecord(value))
+    return false;
+  return isString(value.workspaceId) && isString(value.path) && isString(value.title) && isStringArray(value.sessionIds) && isIsoString(value.createdAt) && isIsoString(value.updatedAt);
+}
+function isRemoteSession(value) {
+  if (!isRecord(value))
+    return false;
+  return isString(value.sessionId) && (value.workspaceId === null || isString(value.workspaceId)) && (value.cwd === null || isString(value.cwd)) && isIsoString(value.createdAt) && typeof value.live === "boolean" && (value.eventCount === null || typeof value.eventCount === "number");
+}
+function isRemoteEvent(value) {
+  return isRecord(value) && typeof value.seq === "number" && isString(value.type) && typeof value.time === "number" && "data" in value;
+}
+function isApiFailure(value) {
+  if (!isRecord(value) || value.ok !== false)
+    return false;
+  const error = value.error;
+  return typeof value.protocolVersion === "number" && isIsoString(value.serverTime) && isRecord(error) && isString(error.code) && isString(error.message) && typeof error.retryable === "boolean";
+}
+function isHostInfoValue(value) {
+  return isHostInfo(value);
+}
+function isListWorkspacesResult(value) {
+  return isRecord(value) && Array.isArray(value.workspaces) && value.workspaces.every(isRemoteWorkspace);
+}
+function isListSessionsResult(value) {
+  return isRecord(value) && Array.isArray(value.sessions) && value.sessions.every(isRemoteSession);
+}
+function isSessionSnapshot(value) {
+  if (!isRecord(value))
+    return false;
+  return isString(value.hostId) && isString(value.sessionId) && typeof value.cursor === "number" && typeof value.live === "boolean" && (value.workspaceId === null || isString(value.workspaceId)) && (value.cwd === null || isString(value.cwd)) && Array.isArray(value.events) && value.events.every(isRemoteEvent) && typeof value.truncated === "boolean";
+}
+function isCreateSessionResult(value) {
+  return isRecord(value) && isString(value.sessionId) && (value.agentPreset === void 0 || isString(value.agentPreset));
+}
+function isAcceptedResult(value) {
+  return isRecord(value) && value.accepted === true;
+}
+function isWebUrlResult(value) {
+  return isRecord(value) && isString(value.path) && value.path.startsWith("/");
+}
+function isSessionStreamFrame(value) {
+  if (!isRecord(value))
+    return false;
+  if (value.type === "ready") {
+    return isString(value.hostId) && isString(value.sessionId) && typeof value.cursor === "number" && typeof value.live === "boolean";
+  }
+  if (value.type === "event") {
+    return typeof value.cursor === "number" && isRemoteEvent(value.event);
+  }
+  if (value.type === "heartbeat") {
+    return typeof value.cursor === "number" && typeof value.time === "number";
+  }
+  if (value.type === "end") {
+    return typeof value.cursor === "number" && isString(value.reason);
+  }
+  return false;
+}
+
+// ../protocol/lib/client.js
+function normalizeBaseUrl(baseUrl) {
+  const url = new URL(baseUrl);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new TypeError(`remote agent base URL must be http(s), got ${url.protocol}`);
+  }
+  return url.origin;
+}
+function fetchWithTimeout(input, init, fetchImpl, timeoutMs, callerSignal) {
+  const timeout = new AbortController();
+  const timer = setTimeout(() => timeout.abort(new Error(`request timed out after ${timeoutMs}ms`)), timeoutMs);
+  timer.unref?.();
+  const signal = callerSignal === void 0 ? timeout.signal : AbortSignal.any([callerSignal, timeout.signal]);
+  return fetchImpl(input, { ...init, signal }).finally(() => clearTimeout(timer));
+}
+var RemoteAgentClient = class {
+  baseUrl;
+  hostId;
+  #token;
+  #timeoutMs;
+  #fetch;
+  constructor(options) {
+    if (options.token.trim() === "")
+      throw new TypeError("remote agent token must not be empty");
+    this.baseUrl = normalizeBaseUrl(options.baseUrl);
+    this.hostId = options.hostId;
+    this.#token = options.token;
+    this.#timeoutMs = options.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    this.#fetch = options.fetchImpl ?? globalThis.fetch;
+  }
+  /** Fetch and validate the agent health document. */
+  health() {
+    return this.#request(AGENT_ROUTES.health, isHostInfoValue);
+  }
+  /** Alias for `health`, named after the protocol capability. */
+  hostInfo() {
+    return this.#request(AGENT_ROUTES.host, isHostInfoValue);
+  }
+  /** List workspaces visible on the remote host. */
+  async listWorkspaces() {
+    const result = await this.#request(AGENT_ROUTES.workspaces, isListWorkspacesResult);
+    return result.workspaces;
+  }
+  /** List sessions, optionally scoped to one remote workspace. */
+  async listSessions(workspaceId) {
+    const path = workspaceId === void 0 ? AGENT_ROUTES.sessions : workspaceSessionsPath(workspaceId);
+    const result = await this.#request(path, isListSessionsResult);
+    return result.sessions;
+  }
+  /** Read the newest page of a session's event log. */
+  snapshotSession(sessionId, options = {}) {
+    const suffix = options.limit === void 0 ? "" : `?limit=${encodeURIComponent(String(options.limit))}`;
+    return this.#request(`${sessionPath(sessionId)}${suffix}`, isSessionSnapshot);
+  }
+  /** Register a remote workspace over the agent API. */
+  createWorkspace(request) {
+    return this.#request(AGENT_ROUTES.workspaces, isRemoteWorkspace, { method: "POST", body: request });
+  }
+  /** Create a remote session in a workspace or directory. */
+  createSession(request) {
+    return this.#request(AGENT_ROUTES.sessions, isCreateSessionResult, {
+      method: "POST",
+      body: request
+    });
+  }
+  /** Send a text prompt to a remote session. */
+  async promptSession(sessionId, request) {
+    await this.#request(sessionPromptPath(sessionId), isAcceptedResult, {
+      method: "POST",
+      body: request
+    });
+  }
+  /** Cancel a remote session's active turn. */
+  async cancelSession(sessionId) {
+    await this.#request(sessionCancelPath(sessionId), isAcceptedResult, {
+      method: "POST",
+      body: {}
+    });
+  }
+  /** Follow the remote approval question stream. */
+  async *followApprovals(signal) {
+    const response = await this.#openStream(AGENT_ROUTES.approvalEvents, signal);
+    const body = response.body;
+    if (body === null) {
+      throw new RemoteProtocolError({ code: "request/invalid", message: "remote agent returned an empty approval stream" });
+    }
+    for await (const message of parseSseStream(body)) {
+      if (message.data === "")
+        continue;
+      let frame;
+      try {
+        frame = JSON.parse(message.data);
+      } catch (error) {
+        throw new RemoteProtocolError({ code: "request/invalid", message: "remote agent sent malformed approval JSON", cause: error });
+      }
+      if (!isRemoteApprovalFrame(frame)) {
+        throw new RemoteProtocolError({ code: "request/invalid", message: "remote agent sent an unknown approval frame" });
+      }
+      yield frame;
+    }
+  }
+  /** Answer one pending remote approval. */
+  answerApproval(id, outcome) {
+    return this.#request(AGENT_ROUTES.approvalAnswer, isAcceptedResult, {
+      method: "POST",
+      body: { id, outcome }
+    });
+  }
+  /** Fetch a browser-authenticated path for the remote Web UI. */
+  webUrl() {
+    return this.#request(AGENT_ROUTES.webUrl, isWebUrlResult);
+  }
+  /**
+   * Follow one session's live events from `cursor`.
+   *
+   * The caller owns reconnection. If the stream drops mid-turn the caller
+   * should request a fresh snapshot and resume from its cursor.
+   */
+  async *followSession(sessionId, cursor, signal) {
+    const response = await this.#openStream(sessionEventsPath(sessionId, cursor), signal);
+    const body = response.body;
+    if (body === null) {
+      throw new RemoteProtocolError({
+        code: "request/invalid",
+        message: "remote agent returned an empty event stream"
+      });
+    }
+    for await (const message of parseSseStream(body)) {
+      if (message.data === "")
+        continue;
+      let frame;
+      try {
+        frame = JSON.parse(message.data);
+      } catch (error) {
+        throw new RemoteProtocolError({
+          code: "request/invalid",
+          message: "remote agent sent malformed event JSON",
+          cause: error
+        });
+      }
+      if (!isSessionStreamFrame(frame)) {
+        throw new RemoteProtocolError({
+          code: "request/invalid",
+          message: "remote agent sent an unknown event frame"
+        });
+      }
+      yield frame;
+    }
+  }
+  /** Validate an event sequence against a cursor. */
+  static guardEvent(cursor, event) {
+    return cursor.accept(event);
+  }
+  async #openStream(path, signal) {
+    const headers = this.#headers();
+    headers.set("accept", "text/event-stream");
+    const response = await this.#fetch(`${this.baseUrl}${path}`, { headers, signal });
+    if (!response.ok)
+      await this.#throwResponseError(response);
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.startsWith("text/event-stream")) {
+      throw new RemoteProtocolError({
+        code: "request/invalid",
+        message: `remote agent returned ${JSON.stringify(contentType)} instead of text/event-stream`
+      });
+    }
+    return response;
+  }
+  async #request(path, guard, init = {}) {
+    const headers = this.#headers();
+    if (init.body !== void 0)
+      headers.set("content-type", "application/json");
+    const response = await fetchWithTimeout(`${this.baseUrl}${path}`, {
+      method: init.method ?? "GET",
+      headers,
+      redirect: "error",
+      ...init.body === void 0 ? {} : { body: JSON.stringify(init.body) }
+    }, this.#fetch, this.#timeoutMs, void 0);
+    if (!response.ok)
+      await this.#throwResponseError(response);
+    const envelope = await response.json().catch((error) => {
+      throw new RemoteProtocolError({
+        code: "request/invalid",
+        message: "remote agent returned invalid JSON",
+        cause: error
+      });
+    });
+    if (isApiFailure(envelope)) {
+      throw new RemoteProtocolError({
+        code: isCode(envelope.error.code) ? envelope.error.code : "internal",
+        message: envelope.error.message,
+        retryable: envelope.error.retryable,
+        details: isDetails(envelope.error.details) ? envelope.error.details : void 0
+      });
+    }
+    if (!isRecord2(envelope) || envelope.ok !== true) {
+      throw new RemoteProtocolError({
+        code: "request/invalid",
+        message: "remote agent returned an unrecognized envelope"
+      });
+    }
+    const serverVersion = typeof envelope.protocolVersion === "number" ? envelope.protocolVersion : Number(response.headers.get(HEADER_SERVER_PROTOCOL_VERSION));
+    if (!isProtocolSupported(serverVersion)) {
+      throw new RemoteProtocolError({
+        code: "protocol/version-mismatch",
+        message: `remote agent speaks protocol ${String(serverVersion)}, this client speaks ${PROTOCOL_VERSION}`,
+        details: { clientVersion: PROTOCOL_VERSION, serverVersion }
+      });
+    }
+    if (!guard(envelope.data)) {
+      throw new RemoteProtocolError({
+        code: "request/invalid",
+        message: "remote agent returned an unexpected response shape"
+      });
+    }
+    return envelope.data;
+  }
+  async #throwResponseError(response) {
+    const body = await response.json().catch(() => void 0);
+    if (isApiFailure(body)) {
+      throw new RemoteProtocolError({
+        code: isCode(body.error.code) ? body.error.code : "internal",
+        message: body.error.message,
+        retryable: body.error.retryable,
+        details: isDetails(body.error.details) ? body.error.details : void 0,
+        httpStatus: response.status
+      });
+    }
+    throw new RemoteProtocolError({
+      code: response.status === 401 ? "auth/invalid" : "internal",
+      message: `remote agent request failed with HTTP ${response.status}`,
+      httpStatus: response.status
+    });
+  }
+  #headers() {
+    const headers = new Headers({
+      accept: "application/json",
+      authorization: `Bearer ${this.#token}`,
+      [HEADER_PROTOCOL_VERSION]: String(PROTOCOL_VERSION)
+    });
+    if (this.hostId !== void 0)
+      headers.set(HEADER_HOST_ID, this.hostId);
+    return headers;
+  }
+};
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isDetails(value) {
+  return isRecord2(value);
+}
+var KNOWN_CODES = /* @__PURE__ */ new Set([
+  "protocol/version-mismatch",
+  "auth/missing",
+  "auth/invalid",
+  "auth/forbidden",
+  "request/invalid",
+  "request/too-large",
+  "route/not-found",
+  "workspace/not-found",
+  "session/not-found",
+  "session/not-live",
+  "agent/not-ready",
+  "internal"
+]);
+function isCode(value) {
+  return KNOWN_CODES.has(value);
+}
+
+// src/credentials/proxy.ts
+import { createServer as createHttpServer, request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+var ModelCredentialProxy = class {
+  #apiKey;
+  #upstream;
+  #host;
+  #timeoutMs;
+  #isTokenValid;
+  #server;
+  constructor(options) {
+    if (options.apiKey.trim() === "") throw new TypeError("credential proxy requires a non-empty API key");
+    this.#apiKey = options.apiKey;
+    this.#upstream = new URL(options.upstreamBaseUrl);
+    if (this.#upstream.protocol !== "http:" && this.#upstream.protocol !== "https:") {
+      throw new TypeError(`credential proxy upstream must be HTTP(S), got ${this.#upstream.protocol}`);
+    }
+    this.#host = options.host ?? "127.0.0.1";
+    this.#timeoutMs = options.timeoutMs ?? 3e5;
+    this.#isTokenValid = options.isTokenValid;
+  }
+  /** Start on an ephemeral loopback port. */
+  async start() {
+    if (this.#server !== void 0) throw new Error("credential proxy already started");
+    const server = createHttpServer((req, res) => this.#forward(req, res));
+    this.#server = server;
+    await new Promise((resolve4, reject) => {
+      server.once("error", reject);
+      server.listen(0, this.#host, () => resolve4());
+    });
+    const address = server.address();
+    return { port: address.port, baseUrl: `http://${this.#host}:${address.port}` };
+  }
+  /** Stop and release active sockets. */
+  async stop() {
+    const server = this.#server;
+    this.#server = void 0;
+    if (server === void 0) return;
+    await new Promise((resolve4) => {
+      server.close(() => resolve4());
+      server.closeAllConnections?.();
+    });
+  }
+  #forward(req, res) {
+    const presented = presentedToken(req);
+    let authorized = false;
+    try {
+      authorized = presented !== void 0 && this.#isTokenValid(presented);
+    } catch {
+      authorized = false;
+    }
+    if (!authorized) {
+      writeError(res, 401, "credential proxy authorization required");
+      return;
+    }
+    let incoming;
+    try {
+      incoming = new URL(req.url ?? "/", "http://credential-proxy.invalid");
+    } catch {
+      writeError(res, 400, "invalid proxy request path");
+      return;
+    }
+    const target = new URL(this.#upstream.origin);
+    const basePath = this.#upstream.pathname.replace(/\/+$/u, "");
+    let incomingPath = incoming.pathname.startsWith("/") ? incoming.pathname : `/${incoming.pathname}`;
+    if (basePath !== "" && (incomingPath === basePath || incomingPath.startsWith(`${basePath}/`))) {
+      incomingPath = incomingPath.slice(basePath.length) || "/";
+    }
+    target.pathname = `${basePath}${incomingPath}` || "/";
+    target.search = incoming.search;
+    const headers = {};
+    for (const [name2, value] of Object.entries(req.headers)) {
+      if (value === void 0) continue;
+      if (name2 === "host" || name2 === "authorization" || name2 === "x-api-key" || name2 === "connection") continue;
+      headers[name2] = value;
+    }
+    headers.authorization = `Bearer ${this.#apiKey}`;
+    headers["x-api-key"] = this.#apiKey;
+    const request = target.protocol === "https:" ? httpsRequest : httpRequest;
+    const upstream = request(target, { method: req.method, headers }, (upstreamResponse) => {
+      res.statusCode = upstreamResponse.statusCode ?? 502;
+      for (const [name2, value] of Object.entries(upstreamResponse.headers)) {
+        if (value !== void 0) res.setHeader(name2, value);
+      }
+      upstreamResponse.pipe(res);
+    });
+    upstream.setTimeout(this.#timeoutMs, () => {
+      upstream.destroy(new Error("upstream credential proxy request timed out"));
+    });
+    upstream.on("error", (error) => {
+      if (!res.headersSent) writeError(res, 502, "model provider request failed");
+      else res.destroy(error);
+    });
+    req.on("aborted", () => upstream.destroy());
+    req.pipe(upstream);
+  }
+};
+function presentedToken(req) {
+  const authorization = req.headers.authorization;
+  if (typeof authorization === "string") {
+    const match = /^Bearer[ \t]+(.+)$/iu.exec(authorization.trim());
+    if (match?.[1] !== void 0) return match[1].trim();
+  }
+  const apiKey = req.headers["x-api-key"];
+  if (typeof apiKey === "string" && apiKey.trim() !== "") return apiKey.trim();
+  return void 0;
+}
+function writeError(res, status, message) {
+  if (res.headersSent) {
+    res.destroy();
+    return;
+  }
+  res.statusCode = status;
+  res.setHeader("content-type", "application/json");
+  res.end(JSON.stringify({ error: { message } }));
+}
+
+// src/hosts/id.ts
+import { createHash as createHash2 } from "node:crypto";
+function isHostId(value) {
+  return /^[a-z0-9][a-z0-9-]{0,63}$/u.test(value);
+}
+function slugify(value) {
+  const slug = value.toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "").slice(0, 40);
+  return slug === "" ? "host" : slug;
+}
+function hostIdFor(canonicalDestination, label) {
+  const hash = createHash2("sha256").update(canonicalDestination).digest("hex").slice(0, 8);
+  return `${slugify(label ?? canonicalDestination)}-${hash}`;
+}
+
+// src/hosts/store.ts
+import { chmod, mkdir as mkdir2, readFile as readFile3, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
+var HOST_STORE_VERSION = 1;
+function isHostRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const record = value;
+  return typeof record.id === "string" && isHostId(record.id) && typeof record.label === "string" && record.label.length > 0 && record.label.length <= 120 && typeof record.sshTarget === "string" && record.sshTarget.length > 0 && (record.sshPort === null || typeof record.sshPort === "number" && Number.isInteger(record.sshPort)) && (record.remoteAgentPort === null || typeof record.remoteAgentPort === "number" && Number.isInteger(record.remoteAgentPort)) && (record.token === null || typeof record.token === "string" && record.token.length >= 16) && (record.proxyToken === void 0 || record.proxyToken === null || typeof record.proxyToken === "string" && record.proxyToken.length >= 16) && typeof record.autoConnect === "boolean" && typeof record.createdAt === "string" && typeof record.updatedAt === "string";
+}
+var HostStore = class {
+  file;
+  #queue = Promise.resolve();
+  constructor(file) {
+    this.file = file;
+  }
+  /** Load valid records; malformed entries are skipped with a warning. */
+  async load() {
+    let raw;
+    try {
+      raw = await readFile3(this.file, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") return { hosts: [], warnings: [] };
+      throw error;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (error) {
+      throw new Error(`host registry ${this.file} is not valid JSON`, { cause: error });
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error(`host registry ${this.file} is not a JSON object`);
+    }
+    const document = parsed;
+    if (document.version !== HOST_STORE_VERSION) {
+      throw new Error(`host registry ${this.file} has unsupported version ${String(document.version)}`);
+    }
+    if (!Array.isArray(document.hosts)) {
+      throw new Error(`host registry ${this.file} has no hosts array`);
+    }
+    const hosts = [];
+    const warnings = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const [index, entry] of document.hosts.entries()) {
+      if (!isHostRecord(entry)) {
+        warnings.push(`host registry entry ${index} is malformed and was ignored`);
+        continue;
+      }
+      if (seen.has(entry.id)) {
+        warnings.push(`host registry entry ${index} duplicates id ${entry.id} and was ignored`);
+        continue;
+      }
+      seen.add(entry.id);
+      hosts.push(entry);
+    }
+    return { hosts, warnings };
+  }
+  /** Current records. */
+  async list() {
+    return (await this.load()).hosts;
+  }
+  /** Add one record, rejecting a duplicate id or destination. */
+  async add(record) {
+    await this.#mutate((hosts) => {
+      if (hosts.some((host) => host.id === record.id)) {
+        throw new Error(`host ${record.id} already exists`);
+      }
+      if (hosts.some((host) => host.sshTarget === record.sshTarget)) {
+        throw new Error(`host ${record.sshTarget} already exists`);
+      }
+      return [...hosts, record];
+    });
+    return record;
+  }
+  /** Merge a patch into one record. */
+  async update(id, patch) {
+    return this.#mutate((hosts) => {
+      const index = hosts.findIndex((host) => host.id === id);
+      if (index < 0) throw new Error(`host ${id} does not exist`);
+      const next = { ...hosts[index], ...patch, id };
+      if (!isHostRecord(next)) throw new Error(`host ${id} update produced an invalid record`);
+      const copy = [...hosts];
+      copy[index] = next;
+      return copy;
+    }).then((records) => records.find((host) => host.id === id));
+  }
+  /** Remove one record. */
+  async remove(id) {
+    const before = await this.list();
+    if (!before.some((host) => host.id === id)) return false;
+    await this.#mutate((hosts) => hosts.filter((host) => host.id !== id));
+    return true;
+  }
+  async #mutate(change) {
+    const run = async () => {
+      const loaded = await this.load();
+      const next = change(loaded.hosts);
+      await this.#write(next);
+      return next;
+    };
+    const task = this.#queue.then(run, run);
+    this.#queue = task.then(() => void 0, () => void 0);
+    return task;
+  }
+  async #write(hosts) {
+    await mkdir2(dirname2(this.file), { recursive: true, mode: 448 });
+    await chmod(dirname2(this.file), 448).catch(() => void 0);
+    const temp = `${this.file}.${randomUUID3()}.tmp`;
+    const document = { version: HOST_STORE_VERSION, hosts };
+    await writeFile2(temp, `${JSON.stringify(document, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+    await chmod(temp, 384);
+    await rename2(temp, this.file);
+  }
+};
+
+// src/hosts/types.ts
+function idleRuntime() {
+  return {
+    phase: "idle",
+    localPort: null,
+    localUrl: null,
+    hostInfo: null,
+    workspaceCount: null,
+    error: null,
+    errorCode: null,
+    connectedAt: null,
+    detail: null,
+    modelProxy: false,
+    modelDirect: false
+  };
+}
+function toHostView(record, runtime) {
+  return {
+    id: record.id,
+    label: record.label,
+    sshTarget: record.sshTarget,
+    sshPort: record.sshPort,
+    remoteAgentPort: record.remoteAgentPort,
+    autoConnect: record.autoConnect,
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt,
+    hasToken: record.token !== null,
+    phase: runtime.phase,
+    localPort: runtime.localPort,
+    localUrl: runtime.localUrl,
+    hostInfo: runtime.hostInfo,
+    workspaceCount: runtime.workspaceCount,
+    error: runtime.error,
+    errorCode: runtime.errorCode,
+    connectedAt: runtime.connectedAt,
+    detail: runtime.detail,
+    modelProxy: runtime.modelProxy,
+    modelDirect: runtime.modelDirect
+  };
+}
+
+// src/remote/provisioner.ts
+import { existsSync, readdirSync } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { join as join6 } from "node:path";
+
+// ../installer/lib/index.js
+import { execFile } from "node:child_process";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join5 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { spawn as spawn4 } from "node:child_process";
+import { execFile as execFile2 } from "node:child_process";
+import { access } from "node:fs/promises";
+var AGENT_API_PREFIX2 = "/dsh-remote-agent/api/v1";
+var MAX_CONTROL_BODY_BYTES2 = 64 * 1024;
+var AGENT_ROUTES2 = {
+  health: `${AGENT_API_PREFIX2}/health`,
+  host: `${AGENT_API_PREFIX2}/host`,
+  workspaces: `${AGENT_API_PREFIX2}/workspaces`,
+  sessions: `${AGENT_API_PREFIX2}/sessions`,
+  webUrl: `${AGENT_API_PREFIX2}/web-url`,
+  approvalEvents: `${AGENT_API_PREFIX2}/approvals/events`,
+  approvalAnswer: `${AGENT_API_PREFIX2}/approvals/answer`
+};
+var SESSION_PREFIX2 = `${AGENT_API_PREFIX2}/sessions/`;
+var WORKSPACE_PREFIX2 = `${AGENT_API_PREFIX2}/workspaces/`;
+function shellLiteral(value) {
+  return `'${value.replace(/'/gu, `'\\''`)}'`;
+}
+function shellPath(value) {
+  if (value === "~") return '"$HOME"';
+  if (value.startsWith("~/")) {
+    const rest = value.slice(2);
+    return `"$HOME/"${shellLiteral(rest)}`;
+  }
+  if (value.startsWith("$HOME/")) {
+    const rest = value.slice("$HOME/".length);
+    return `"$HOME/"${shellLiteral(rest)}`;
+  }
+  return shellLiteral(value);
+}
+function renderSystemdUnit(options) {
+  return [
+    "[Unit]",
+    "Description=DSH remote agent (DeepSeek Harness Web)",
+    "After=network.target",
+    "",
+    "[Service]",
+    "Type=simple",
+    'Environment="DSH_HOME=$DSH_HOME"',
+    // $PATH is expanded by the bootstrap shell after nodePathPrelude(), so the
+    // systemd unit sees the discovered nvm/Volta/fnm Node bin directory too.
+    'Environment="PATH=$INSTALL_DIR/node/bin:$INSTALL_DIR/node_modules/.bin:/usr/local/bin:/usr/bin:/bin:$PATH"',
+    ...options.modelBaseUrl === void 0 ? [] : ['Environment="DEEPSEEK_BASE_URL=$MODEL_BASE_URL"'],
+    ...options.modelApiKey === void 0 ? [] : ['Environment="DEEPSEEK_API_KEY=$MODEL_API_KEY"'],
+    'ExecStart="$DSH_BIN" web --host 127.0.0.1 --port $PORT --no-open',
+    "Restart=always",
+    "RestartSec=3",
+    "WorkingDirectory=$DSH_HOME",
+    "",
+    "[Install]",
+    "WantedBy=default.target",
+    ""
+  ].join("\n");
+}
+function nodePathPrelude() {
+  return `if ! command -v node >/dev/null 2>&1; then
+  for candidate in \\
+    "$HOME/.volta/bin" \\
+    "$HOME/.local/share/fnm" \\
+    "$HOME/.bun/bin" \\
+    "$HOME/.asdf/shims" \\
+    "$HOME/.local/share/mise/shims" \\
+    "$HOME/.nix-profile/bin" \\
+    "$HOME/.n/bin" \\
+    "$HOME/.local/bin" \\
+    "/opt/homebrew/bin" \\
+    "/usr/local/bin"; do
+    if [ -d "$candidate" ]; then PATH="$candidate:$PATH"; fi
+  done
+  NODE_BIN_DIR="$(ls -d "$HOME"/.nvm/versions/node/*/bin 2>/dev/null | sort -V | tail -1)"
+  if [ -n "$NODE_BIN_DIR" ]; then PATH="$NODE_BIN_DIR:$PATH"; fi
+  if ! command -v node >/dev/null 2>&1; then
+    LOGIN_SHELL="\${SHELL:-}"
+    if command -v getent >/dev/null 2>&1; then
+      LOGIN_SHELL="$(getent passwd "$(id -un)" 2>/dev/null | cut -d: -f7)"
+    fi
+    case "$LOGIN_SHELL" in
+      */bash|*/zsh|*/sh|*/dash|*/ksh)
+        NODE_BIN="$(env -i HOME="$HOME" PATH="$PATH" "$LOGIN_SHELL" -lc 'command -v node' 2>/dev/null | tail -n 1 || true)"
+        if [ -n "$NODE_BIN" ] && [ -x "$NODE_BIN" ]; then PATH="$(dirname "$NODE_BIN"):$PATH"; fi
+        ;;
+    esac
+  fi
+  export PATH
+fi`;
+}
+function nodeInstallFunction() {
+  return `install_node() {
+  case "$(uname -s)" in
+    Linux) NODE_OS=linux ;;
+    Darwin) NODE_OS=darwin ;;
+    *) echo "dsh-remote: unsupported OS for automatic Node.js install: $(uname -s)" >&2; return 1 ;;
+  esac
+  case "$(uname -m)" in
+    x86_64|amd64) NODE_ARCH=x64 ;;
+    aarch64|arm64) NODE_ARCH=arm64 ;;
+    armv7l) NODE_ARCH=armv7l ;;
+    *) echo "dsh-remote: unsupported architecture for automatic Node.js install: $(uname -m)" >&2; return 1 ;;
+  esac
+
+  NODE_INSTALL_ROOT="$INSTALL_DIR/node"
+  NODE_DOWNLOAD="$INSTALL_DIR/.node-download.$$"
+  NODE_ARCHIVE="node-v$NODE_VERSION-$NODE_OS-$NODE_ARCH.tar.gz"
+  NODE_URL="https://nodejs.org/dist/v$NODE_VERSION"
+  rm -rf "$NODE_DOWNLOAD"
+  mkdir -p "$NODE_DOWNLOAD"
+  echo "dsh-remote: downloading Node.js $NODE_VERSION ($NODE_OS-$NODE_ARCH)"
+  if command -v curl >/dev/null 2>&1; then
+    if ! curl -fsSL --retry 3 "$NODE_URL/SHASUMS256.txt" -o "$NODE_DOWNLOAD/SHASUMS256.txt" \\
+      || ! curl -fsSL --retry 3 "$NODE_URL/$NODE_ARCHIVE" -o "$NODE_DOWNLOAD/$NODE_ARCHIVE"; then
+      echo "dsh-remote: could not download Node.js from $NODE_URL" >&2
+      rm -rf "$NODE_DOWNLOAD"
+      return 1
+    fi
+  elif command -v wget >/dev/null 2>&1; then
+    if ! wget -q -O "$NODE_DOWNLOAD/SHASUMS256.txt" "$NODE_URL/SHASUMS256.txt" \\
+      || ! wget -q -O "$NODE_DOWNLOAD/$NODE_ARCHIVE" "$NODE_URL/$NODE_ARCHIVE"; then
+      echo "dsh-remote: could not download Node.js from $NODE_URL" >&2
+      rm -rf "$NODE_DOWNLOAD"
+      return 1
+    fi
+  else
+    echo "dsh-remote: curl or wget is required to install Node.js automatically" >&2
+    rm -rf "$NODE_DOWNLOAD"
+    return 1
+  fi
+
+  EXPECTED="$(awk -v name="$NODE_ARCHIVE" '$2 == name { print $1; exit }' "$NODE_DOWNLOAD/SHASUMS256.txt")"
+  if [ -z "$EXPECTED" ]; then
+    echo "dsh-remote: Node.js checksum is missing from SHASUMS256.txt" >&2
+    rm -rf "$NODE_DOWNLOAD"
+    return 1
+  fi
+  if command -v sha256sum >/dev/null 2>&1; then
+    ACTUAL="$(sha256sum "$NODE_DOWNLOAD/$NODE_ARCHIVE" | awk '{ print $1 }')"
+  elif command -v shasum >/dev/null 2>&1; then
+    ACTUAL="$(shasum -a 256 "$NODE_DOWNLOAD/$NODE_ARCHIVE" | awk '{ print $1 }')"
+  else
+    echo "dsh-remote: sha256sum or shasum is required to verify Node.js" >&2
+    rm -rf "$NODE_DOWNLOAD"
+    return 1
+  fi
+  if [ "$EXPECTED" != "$ACTUAL" ]; then
+    echo "dsh-remote: Node.js checksum mismatch" >&2
+    rm -rf "$NODE_DOWNLOAD"
+    return 1
+  fi
+  if ! command -v tar >/dev/null 2>&1; then
+    echo "dsh-remote: tar is required to install Node.js automatically" >&2
+    rm -rf "$NODE_DOWNLOAD"
+    return 1
+  fi
+
+  rm -rf "$NODE_INSTALL_ROOT"
+  mkdir -p "$NODE_INSTALL_ROOT"
+  if ! tar -xzf "$NODE_DOWNLOAD/$NODE_ARCHIVE" -C "$NODE_INSTALL_ROOT" --strip-components=1; then
+    echo "dsh-remote: could not extract Node.js" >&2
+    rm -rf "$NODE_DOWNLOAD" "$NODE_INSTALL_ROOT"
+    return 1
+  fi
+  rm -rf "$NODE_DOWNLOAD"
+  PATH="$NODE_INSTALL_ROOT/bin:$PATH"
+  export PATH
+  echo "dsh-remote: installed Node.js $NODE_VERSION at $NODE_INSTALL_ROOT"
+}`;
+}
+function renderBootstrapScript(options) {
+  const startBlock = renderStartBlock(options);
+  return `#!/usr/bin/env bash
+# dsh-remote installer bootstrap \u2014 generated, no secrets embedded.
+set -euo pipefail
+
+INSTALL_DIR=${shellPath(options.installDir)}
+DSH_HOME=${shellPath(options.dshHome)}
+PROFILE=${shellLiteral(options.profile)}
+PORT=${shellLiteral(String(options.port))}
+DSH_VERSION=${shellLiteral(options.dshVersion)}
+PNPM_VERSION=${shellLiteral(options.pnpmVersion)}
+NODE_VERSION=${shellLiteral(options.nodeVersion)}
+AUTO_INSTALL_NODE=${options.autoInstallNode ? "1" : "0"}
+AGENT_TARBALL=${shellLiteral(options.agentTarball)}
+MODEL_BASE_URL=${options.modelBaseUrl === void 0 ? "''" : shellLiteral(options.modelBaseUrl)}
+MODEL_API_KEY=${options.modelApiKey === void 0 ? "''" : shellLiteral(options.modelApiKey)}
+STATE_FILE="$DSH_HOME/remote-agent/agent.json"
+WAIT_FOR_STATE=${options.start === "none" ? 0 : 1}
+
+export DSH_HOME
+mkdir -p "$INSTALL_DIR" "$DSH_HOME/remote-agent"
+
+${nodePathPrelude()}
+
+${nodeInstallFunction()}
+if ! command -v node >/dev/null 2>&1   || ! node -e 'const [major, minor] = process.versions.node.split(".").map(Number); process.exit(major > 22 || (major === 22 && minor >= 19) ? 0 : 1)' >/dev/null 2>&1   || ! command -v npm >/dev/null 2>&1; then
+  if [ "$AUTO_INSTALL_NODE" -eq 1 ]; then
+    install_node || exit 25
+  fi
+fi
+if ! command -v node >/dev/null 2>&1; then
+  echo "dsh-remote: Node.js is required but not on PATH; rerun with automatic Node.js installation enabled" >&2
+  exit 21
+fi
+if ! node -e 'const [major, minor] = process.versions.node.split(".").map(Number); process.exit(major > 22 || (major === 22 && minor >= 19) ? 0 : 1)'; then
+  echo "dsh-remote: Node.js 22.19+ is required (found $(node --version))" >&2
+  exit 22
+fi
+if ! command -v npm >/dev/null 2>&1; then
+  echo "dsh-remote: npm is required; install a Node.js distribution that includes npm" >&2
+  exit 23
+fi
+
+export PATH="$INSTALL_DIR/node_modules/.bin:$PATH"
+if ! command -v pnpm >/dev/null 2>&1; then
+  echo "dsh-remote: installing pnpm@$PNPM_VERSION into $INSTALL_DIR"
+  npm install --prefix "$INSTALL_DIR" --no-audit --no-fund "pnpm@$PNPM_VERSION"
+fi
+
+DSH_BIN="$INSTALL_DIR/node_modules/.bin/dsh"
+if [ ! -x "$DSH_BIN" ]; then
+  echo "dsh-remote: installing @deepseek-ai/dsh@$DSH_VERSION into $INSTALL_DIR"
+  npm install --prefix "$INSTALL_DIR" --no-audit --no-fund "@deepseek-ai/dsh@$DSH_VERSION"
+fi
+if [ ! -x "$DSH_BIN" ]; then
+  echo "dsh-remote: dsh installation did not produce $DSH_BIN" >&2
+  exit 24
+fi
+
+echo "dsh-remote: adding plugin to profile $PROFILE"
+"$DSH_BIN" plugin --profile "$PROFILE" add "$AGENT_TARBALL"
+
+${startBlock}
+
+if [ "$WAIT_FOR_STATE" -eq 1 ]; then
+  i=0
+  while [ "$i" -lt 60 ]; do
+    if [ -s "$STATE_FILE" ]; then break; fi
+    sleep 1
+    i=$((i + 1))
+  done
+fi
+
+echo "dsh-remote: installed"
+echo "dsh-remote: state file $STATE_FILE"
+if [ "$WAIT_FOR_STATE" -eq 1 ] && [ -s "$STATE_FILE" ]; then
+  PORT_VALUE=$(sed -n 's/.*"port": *\\([0-9][0-9]*\\).*/\\1/p' "$STATE_FILE" | head -1)
+  echo "dsh-remote: remote agent port \${PORT_VALUE:-unknown}"
+else
+  echo "dsh-remote: warning: the agent state file is not ready yet; inspect the remote DSH log" >&2
+fi
+`;
+}
+function renderStartBlock(options) {
+  if (options.start === "none") {
+    return 'echo "dsh-remote: start mode none; start dsh web yourself"';
+  }
+  if (options.start === "nohup") {
+    return renderNohup(options);
+  }
+  const unit = renderSystemdUnit(options);
+  return `UNIT_DIR="$HOME/.config/systemd/user"
+mkdir -p "$UNIT_DIR"
+umask 077
+cat > "$UNIT_DIR/dsh-remote-agent.service" <<DSH_REMOTE_UNIT
+${unit}DSH_REMOTE_UNIT
+chmod 600 "$UNIT_DIR/dsh-remote-agent.service"
+
+if command -v systemctl >/dev/null 2>&1 && systemctl --user daemon-reload >/dev/null 2>&1; then
+  if systemctl --user enable dsh-remote-agent.service >/dev/null 2>&1     && systemctl --user restart dsh-remote-agent.service; then
+    echo "dsh-remote: restarted systemd user unit dsh-remote-agent.service"
+  else
+    echo "dsh-remote: systemd user unit failed; falling back to nohup" >&2
+    ${renderNohup(options)}
+  fi
+else
+  echo "dsh-remote: systemd user manager unavailable; falling back to nohup" >&2
+  ${renderNohup(options)}
+fi`;
+}
+function renderNohup(options) {
+  const modelEnv = options.modelBaseUrl === void 0 ? "" : `DEEPSEEK_BASE_URL="$MODEL_BASE_URL" DEEPSEEK_API_KEY="$MODEL_API_KEY" `;
+  return `if [ -f "$DSH_HOME/remote-agent/web.pid" ]; then
+  kill "$(cat "$DSH_HOME/remote-agent/web.pid")" 2>/dev/null || true
+fi
+${modelEnv}nohup "$DSH_BIN" web --host 127.0.0.1 --port "$PORT" --no-open > "$DSH_HOME/remote-agent/web.log" 2>&1 &
+echo $! > "$DSH_HOME/remote-agent/web.pid"
+echo "dsh-remote: started dsh web under nohup (pid $(cat "$DSH_HOME/remote-agent/web.pid"))"`;
+}
+var SshTargetError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SshTargetError";
+  }
+};
+function parseTarget(raw) {
+  const input = raw.trim();
+  if (input === "") throw new SshTargetError("SSH target must not be empty");
+  if (/[\s\u0000-\u001f]/u.test(input)) throw new SshTargetError("SSH target must not contain whitespace");
+  if (input.startsWith("-")) throw new SshTargetError('SSH target must not start with "-"');
+  let user = null;
+  let hostAndPort = input;
+  if (input.startsWith("ssh://")) {
+    let url;
+    try {
+      url = new URL(input);
+    } catch (error) {
+      throw new SshTargetError(`invalid ssh URL: ${input}`);
+    }
+    if (url.protocol !== "ssh:") throw new SshTargetError(`unsupported scheme: ${url.protocol}`);
+    if (url.pathname !== "" && url.pathname !== "/") throw new SshTargetError("ssh URL must not contain a path");
+    user = url.username === "" ? null : decodeURIComponent(url.username);
+    const port2 = url.port === "" ? null : Number(url.port);
+    return validate(input, user, url.hostname, port2);
+  }
+  const at = input.indexOf("@");
+  if (at >= 0) {
+    user = input.slice(0, at);
+    hostAndPort = input.slice(at + 1);
+  }
+  let host = hostAndPort;
+  let port = null;
+  const colon = hostAndPort.lastIndexOf(":");
+  if (colon >= 0) {
+    const portText = hostAndPort.slice(colon + 1);
+    if (!/^\d{1,5}$/u.test(portText)) throw new SshTargetError(`invalid SSH port: ${portText}`);
+    host = hostAndPort.slice(0, colon);
+    port = Number(portText);
+  }
+  return validate(input, user, host, port);
+}
+function validate(raw, user, host, port) {
+  if (user !== null && !/^[A-Za-z0-9_][A-Za-z0-9._-]{0,63}$/u.test(user)) {
+    throw new SshTargetError(`invalid SSH user: ${JSON.stringify(user)}`);
+  }
+  if (!/^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,252}[A-Za-z0-9])?$/u.test(host)) {
+    throw new SshTargetError(`unsupported SSH host: ${JSON.stringify(host)}`);
+  }
+  if (port !== null && (!Number.isInteger(port) || port < 1 || port > 65535)) {
+    throw new SshTargetError(`invalid SSH port: ${String(port)}`);
+  }
+  const destination = user === null ? host : `${user}@${host}`;
+  return {
+    raw,
+    destination,
+    port,
+    canonical: port === null ? destination : `${destination}:${port}`
+  };
+}
+function sshArgs(target, options) {
+  return [
+    "-o",
+    "BatchMode=yes",
+    "-o",
+    `ConnectTimeout=${Math.max(1, Math.ceil(options.timeoutMs / 1e3))}`,
+    "-o",
+    `StrictHostKeyChecking=${options.strictHostKeyChecking}`,
+    "-o",
+    "ServerAliveInterval=15",
+    "-o",
+    "ServerAliveCountMax=3",
+    ...target.port === null ? [] : ["-p", String(target.port)]
+  ];
+}
+function runRemoteScript(target, script, options) {
+  return new Promise((resolve4, reject) => {
+    const child = spawn4(options.binary, [...sshArgs(target, options), target.destination, "bash -s"], {
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true
+    });
+    const stdout = [];
+    const stderr = [];
+    let bytes = 0;
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      child.kill("SIGKILL");
+      reject(new Error(`remote bootstrap timed out after ${options.timeoutMs}ms`));
+    }, options.timeoutMs);
+    timer.unref?.();
+    const append = (target2, chunk) => {
+      bytes += chunk.length;
+      if (bytes > 4 * 1024 * 1024) {
+        child.kill("SIGKILL");
+        return;
+      }
+      target2.push(chunk);
+      if (options.verbose) process.stderr.write(chunk);
+    };
+    child.stdout.on("data", (chunk) => append(stdout, chunk));
+    child.stderr.on("data", (chunk) => append(stderr, chunk));
+    child.stdin.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.once("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.once("exit", (code, signal) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      const result = {
+        stdout: Buffer.concat(stdout).toString("utf8"),
+        stderr: Buffer.concat(stderr).toString("utf8"),
+        code: code ?? (signal === null ? 1 : 137)
+      };
+      if (result.code === 0) resolve4(result);
+      else reject(Object.assign(new Error(`remote bootstrap exited with ${String(result.code)}`), { result }));
+    });
+    child.stdin.end(script);
+  });
+}
+var execFileAsync = promisify(execFile);
+async function provisionRemoteAgent(options) {
+  const target = parseTarget(options.target);
+  await access(options.agentTarballPath);
+  const remoteTarball = `/tmp/dsh-remote-agent-${Date.now()}-${process.pid}.tgz`;
+  const timeoutMs = Math.max(options.timeoutMs ?? 6e5, 6e5);
+  await uploadFile2(options.agentTarballPath, remoteTarball, target, options);
+  const script = renderBootstrapScript({
+    profile: options.profile,
+    port: 0,
+    installDir: options.installDir,
+    dshHome: options.dshHome,
+    dshVersion: options.dshVersion,
+    pnpmVersion: options.pnpmVersion,
+    nodeVersion: options.nodeVersion,
+    autoInstallNode: options.autoInstallNode,
+    start: options.start,
+    agentTarball: remoteTarball,
+    ...options.modelBaseUrl === void 0 ? {} : { modelBaseUrl: options.modelBaseUrl },
+    ...options.modelApiKey === void 0 ? {} : { modelApiKey: options.modelApiKey }
+  });
+  const result = await runRemoteScript(target, script, {
+    binary: options.sshBinary,
+    strictHostKeyChecking: options.strictHostKeyChecking,
+    timeoutMs,
+    verbose: options.verbose ?? false
+  });
+  return { stdout: result.stdout, stderr: result.stderr, remoteTarball };
+}
+function uploadFile2(local, remote, target, options) {
+  return new Promise((resolve4, reject) => {
+    const args = [
+      "-o",
+      `StrictHostKeyChecking=${options.strictHostKeyChecking}`,
+      ...target.port === null ? [] : ["-P", String(target.port)],
+      local,
+      `${target.destination}:${remote}`
+    ];
+    const child = execFile2("scp", args, { timeout: 12e4 }, (error) => {
+      if (error === null) resolve4();
+      else reject(error);
+    });
+    if (options.verbose === true) {
+      child.stderr?.on("data", (chunk) => process.stderr.write(chunk));
+    }
+  });
+}
+
+// src/ssh/probe.ts
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync2 = promisify2(execFile3);
+function shellQuote2(value) {
+  return `'${value.replace(/'/gu, `'\\''`)}'`;
+}
+function discoveryCommand(remoteStateFile) {
+  const path = remoteStateFile.trim();
+  if (path === "") throw new LocalError("host/invalid", "remote state file must not be empty");
+  if (/[\u0000-\u001f]/u.test(path)) {
+    throw new LocalError("host/invalid", "remote state file must not contain control characters");
+  }
+  if (path === "~") return 'cat -- "$HOME" 2>/dev/null || true';
+  if (path.startsWith("~/")) {
+    const rest = path.slice(2);
+    return `cat -- "$HOME/${rest.replace(/([\\"$`])/gu, "\\$1")}" 2>/dev/null || true`;
+  }
+  return `cat -- ${shellQuote2(path)} 2>/dev/null || true`;
+}
+function baseSshArgs(target, options) {
+  return [
+    "-o",
+    "BatchMode=yes",
+    "-o",
+    `ConnectTimeout=${Math.max(1, Math.ceil(options.timeoutMs / 1e3))}`,
+    "-o",
+    `StrictHostKeyChecking=${options.strictHostKeyChecking}`,
+    "-o",
+    "ServerAliveInterval=15",
+    "-o",
+    "ServerAliveCountMax=3",
+    ...target.port === null ? [] : ["-p", String(target.port)]
+  ];
+}
+async function discoverAgent(target, options) {
+  const started = Date.now();
+  const command = discoveryCommand(options.remoteStateFile);
+  let stdout;
+  let stderr;
+  try {
+    const result = await execFileAsync2(
+      options.sshBinary,
+      [...baseSshArgs(target, options), target.destination, command],
+      {
+        timeout: options.timeoutMs,
+        maxBuffer: 256 * 1024,
+        encoding: "utf8",
+        windowsHide: true
+      }
+    );
+    stdout = result.stdout;
+    stderr = result.stderr;
+  } catch (error) {
+    const failure = error;
+    const detail = (failure.stderr ?? "").trim().split("\n")[0] ?? "";
+    const message = failure.killed === true ? `SSH discovery timed out after ${options.timeoutMs}ms` : detail !== "" ? `SSH discovery failed: ${detail}` : `SSH discovery failed: ${failure.message}`;
+    throw new LocalError("ssh/probe-failed", message, {
+      details: { host: target.canonical, ...failure.code === void 0 ? {} : { code: failure.code } },
+      cause: error
+    });
+  }
+  if (stdout.trim() === "") {
+    const hint = stderr.trim() === "" ? "" : ` (${stderr.trim().split("\n")[0]})`;
+    throw new LocalError(
+      "agent/unavailable",
+      `remote agent state file was not found at ${options.remoteStateFile}; install dsh-remote-agent and start the remote DSH web host${hint}`,
+      { details: { host: target.canonical, remoteStateFile: options.remoteStateFile } }
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch (error) {
+    throw new LocalError("agent/unavailable", "remote agent state file is not valid JSON", {
+      details: { host: target.canonical },
+      cause: error
+    });
+  }
+  if (!isAgentDiscoveryState(parsed)) {
+    throw new LocalError("agent/unavailable", "remote agent state file has an unexpected shape", {
+      details: { host: target.canonical }
+    });
+  }
+  if (!isAgentLive(parsed)) {
+    throw new LocalError(
+      "agent/unavailable",
+      "remote agent is installed but its DSH web listener is not running; start `dsh web` on the remote host",
+      { details: { host: target.canonical }, retryable: true }
+    );
+  }
+  return { state: parsed, latencyMs: Date.now() - started };
+}
+
+// src/remote/provisioner.ts
+var RemoteProvisioner = class {
+  #config;
+  constructor(config) {
+    this.#config = config;
+  }
+  /**
+   * Install/start the remote agent when discovery finds no live agent.
+   *
+   * @param target - validated SSH target.
+   * @param options - optional local proxy endpoint and progress callback.
+   */
+  async ensureInstalled(target, options = {}) {
+    const tarball = findAgentTarball();
+    options.onProgress?.("\u6B63\u5728\u8FDC\u7AEF\u5B89\u88C5 DSH \u4E0E dsh-remote-agent\uFF08\u9996\u6B21\u7EA6 1\u20133 \u5206\u949F\uFF09\u2026");
+    try {
+      await provisionRemoteAgent({
+        target: target.canonical,
+        agentTarballPath: tarball,
+        sshBinary: this.#config.sshBinary,
+        strictHostKeyChecking: this.#config.strictHostKeyChecking,
+        profile: "web",
+        installDir: this.#config.remoteInstallDir,
+        dshHome: this.#config.remoteDshHome,
+        dshVersion: this.#config.remoteDshVersion,
+        pnpmVersion: this.#config.remotePnpmVersion,
+        nodeVersion: this.#config.remoteNodeVersion,
+        autoInstallNode: this.#config.autoInstallNode,
+        start: this.#config.remoteStart,
+        timeoutMs: this.#config.provisionTimeoutMs,
+        ...options.modelBaseUrl === void 0 ? {} : { modelBaseUrl: options.modelBaseUrl },
+        ...options.modelApiKey === void 0 ? {} : { modelApiKey: options.modelApiKey },
+        verbose: false
+      });
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new LocalError("agent/unavailable", `\u8FDC\u7AEF\u81EA\u52A8\u5B89\u88C5\u5931\u8D25\uFF1A${detail}`, {
+        details: { host: target.canonical },
+        retryable: true,
+        cause: error
+      });
+    }
+    options.onProgress?.("\u8FDC\u7AEF\u5B89\u88C5\u5B8C\u6210\uFF0C\u7B49\u5F85 DSH web \u542F\u52A8\u2026");
+    await this.#waitForAgent(target, options.onProgress, options.signal);
+  }
+  async #waitForAgent(target, onProgress, signal) {
+    const deadline = Date.now() + 12e4;
+    let lastError;
+    while (Date.now() < deadline) {
+      if (signal?.aborted === true) throw new LocalError("internal", "\u8FDC\u7AEF\u5B89\u88C5\u5DF2\u53D6\u6D88");
+      try {
+        const discovered = await discoverAgent(target, {
+          sshBinary: this.#config.sshBinary,
+          timeoutMs: this.#config.probeTimeoutMs,
+          strictHostKeyChecking: this.#config.strictHostKeyChecking,
+          remoteStateFile: this.#config.remoteStateFile
+        });
+        if (isAgentLive(discovered.state)) return;
+      } catch (error) {
+        lastError = error;
+        onProgress?.("\u7B49\u5F85\u8FDC\u7AEF dsh web \u5C31\u7EEA\u2026");
+      }
+      await new Promise((resolve4) => setTimeout(resolve4, 2e3));
+    }
+    throw new LocalError("agent/unavailable", "\u8FDC\u7AEF DSH web \u672A\u80FD\u5728 120 \u79D2\u5185\u542F\u52A8", {
+      details: { host: target.canonical, reason: lastError instanceof Error ? lastError.message : String(lastError) },
+      retryable: true
+    });
+  }
+};
+function findAgentTarball() {
+  const candidates = [
+    new URL("../assets", import.meta.url),
+    new URL("../../assets", import.meta.url)
+  ];
+  for (const candidate of candidates) {
+    const dir = fileURLToPath2(candidate);
+    if (!existsSync(dir)) continue;
+    const tarball = readdirSync(dir).find((name2) => name2.endsWith(".tgz"));
+    if (tarball !== void 0) return join6(dir, tarball);
+  }
+  throw new LocalError(
+    "internal",
+    "\u672C\u5730\u63D2\u4EF6\u6CA1\u6709\u5185\u7F6E dsh-remote-agent \u5B89\u88C5\u5305\uFF1B\u8BF7\u91CD\u65B0\u6267\u884C pnpm build \u751F\u6210 assets"
+  );
+}
+
+// src/ssh/target.ts
+var USER_PATTERN = /^[A-Za-z0-9_][A-Za-z0-9._-]{0,63}$/u;
+var HOST_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,252}[A-Za-z0-9])?$/u;
+function parseSshTarget(raw) {
+  const input = raw.trim();
+  if (input === "") {
+    throw new LocalError("host/invalid", "SSH target must not be empty");
+  }
+  if (/[\s\u0000-\u001f]/u.test(input)) {
+    throw new LocalError("host/invalid", "SSH target must not contain whitespace or control characters");
+  }
+  if (input.startsWith("-")) {
+    throw new LocalError("host/invalid", 'SSH target must not start with "-"');
+  }
+  let user = null;
+  let hostAndPort = input;
+  if (input.startsWith("ssh://")) {
+    let url;
+    try {
+      url = new URL(input);
+    } catch (error) {
+      throw new LocalError("host/invalid", `invalid ssh URL: ${input}`, { cause: error });
+    }
+    if (url.protocol !== "ssh:") {
+      throw new LocalError("host/invalid", `unsupported SSH URL scheme: ${url.protocol}`);
+    }
+    if (url.pathname !== "" && url.pathname !== "/") {
+      throw new LocalError("host/invalid", "ssh URL must not contain a path");
+    }
+    if (url.username === "" && url.password !== "") {
+      throw new LocalError("host/invalid", "ssh URL password is not supported; use keys or ssh-agent");
+    }
+    user = url.username === "" ? null : decodeURIComponent(url.username);
+    if (url.hostname === "") {
+      throw new LocalError("host/invalid", "ssh URL has no hostname");
+    }
+    const port2 = url.port === "" ? null : Number(url.port);
+    return validate2({ raw: input, user, host: url.hostname, port: port2 });
+  }
+  const at = input.indexOf("@");
+  if (at >= 0) {
+    user = input.slice(0, at);
+    hostAndPort = input.slice(at + 1);
+    if (user === "") {
+      throw new LocalError("host/invalid", "SSH target has an empty user");
+    }
+  }
+  let host = hostAndPort;
+  let port = null;
+  const colon = hostAndPort.lastIndexOf(":");
+  if (colon >= 0) {
+    const portText = hostAndPort.slice(colon + 1);
+    host = hostAndPort.slice(0, colon);
+    if (!/^\d{1,5}$/u.test(portText)) {
+      throw new LocalError("host/invalid", `invalid SSH port: ${JSON.stringify(portText)}`);
+    }
+    port = Number(portText);
+  }
+  return validate2({ raw: input, user, host, port });
+}
+function validate2(input) {
+  if (input.user !== null && !USER_PATTERN.test(input.user)) {
+    throw new LocalError("host/invalid", `invalid SSH user: ${JSON.stringify(input.user)}`);
+  }
+  if (!HOST_PATTERN.test(input.host)) {
+    throw new LocalError("host/invalid", `unsupported SSH host: ${JSON.stringify(input.host)}`);
+  }
+  if (input.port !== null && (!Number.isInteger(input.port) || input.port < 1 || input.port > 65535)) {
+    throw new LocalError("host/invalid", `SSH port must be between 1 and 65535, got ${String(input.port)}`);
+  }
+  const destination = input.user === null ? input.host : `${input.user}@${input.host}`;
+  const canonical = input.port === null ? destination : `${destination}:${input.port}`;
+  return {
+    raw: input.raw,
+    user: input.user,
+    host: input.host,
+    port: input.port,
+    destination,
+    canonical
+  };
+}
+function validateHostLabel(label) {
+  const value = label.trim();
+  if (value === "") throw new LocalError("host/invalid", "host label must not be empty");
+  if (value.length > 120) throw new LocalError("host/invalid", "host label must be at most 120 characters");
+  if (/[\u0000-\u001f]/u.test(value)) throw new LocalError("host/invalid", "host label must not contain control characters");
+  return value;
+}
+
+// src/ssh/tunnel.ts
+import { spawn as spawn5 } from "node:child_process";
+import { createServer, connect } from "node:net";
+function tunnelArgs(options, localPort) {
+  if (!Number.isInteger(options.remotePort) || options.remotePort < 1 || options.remotePort > 65535) {
+    throw new LocalError("host/invalid", `remote agent port is invalid: ${String(options.remotePort)}`);
+  }
+  return [
+    ...baseSshArgs(options.target, {
+      timeoutMs: options.connectTimeoutMs,
+      strictHostKeyChecking: options.strictHostKeyChecking
+    }),
+    "-N",
+    "-o",
+    "ExitOnForwardFailure=yes",
+    "-L",
+    `127.0.0.1:${localPort}:127.0.0.1:${options.remotePort}`,
+    ...options.reverseForward === void 0 ? [] : [
+      "-R",
+      `127.0.0.1:${options.reverseForward.remotePort}:127.0.0.1:${options.reverseForward.localPort}`
+    ],
+    options.target.destination
+  ];
+}
+async function allocateLocalPort() {
+  return new Promise((resolve4, reject) => {
+    const server = createServer();
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (address === null || typeof address === "string") {
+        server.close();
+        reject(new Error("could not allocate a loopback port"));
+        return;
+      }
+      const port = address.port;
+      server.close((error) => error === void 0 ? resolve4(port) : reject(error));
+    });
+  });
+}
+async function waitForPort(port, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    const connected = await tryConnect(port);
+    if (connected) return;
+    if (Date.now() >= deadline) throw new Error(`timed out waiting for 127.0.0.1:${port}`);
+    await new Promise((resolve4) => setTimeout(resolve4, 80));
+  }
+}
+function tryConnect(port) {
+  return new Promise((resolve4) => {
+    const socket = connect({ host: "127.0.0.1", port });
+    const finish = (value) => {
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve4(value);
+    };
+    socket.once("connect", () => finish(true));
+    socket.once("error", () => finish(false));
+    socket.setTimeout(500, () => finish(false));
+  });
+}
+var Tunnel = class _Tunnel {
+  localPort;
+  localUrl;
+  #options;
+  #child;
+  #stderr = [];
+  #stderrBytes = 0;
+  #stopping = false;
+  #exited = false;
+  constructor(options, localPort, child) {
+    this.#options = options;
+    this.localPort = localPort;
+    this.localUrl = `http://127.0.0.1:${localPort}`;
+    this.#child = child;
+    child.stderr?.on("data", (chunk) => {
+      this.#stderr.push(chunk);
+      this.#stderrBytes += chunk.length;
+      while (this.#stderrBytes > 8 * 1024 && this.#stderr.length > 1) {
+        const removed = this.#stderr.shift();
+        this.#stderrBytes -= removed?.length ?? 0;
+      }
+    });
+    child.once("exit", (code, signal) => {
+      this.#exited = true;
+      if (this.#stopping) return;
+      options.onExit?.({ code, signal, stderr: this.stderr });
+    });
+  }
+  /** Start a tunnel, retrying port allocation if the first bind races. */
+  static async start(options, attempts = 3) {
+    let lastError;
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+      const localPort = await allocateLocalPort();
+      const child = spawn5(options.sshBinary, tunnelArgs(options, localPort), {
+        stdio: ["ignore", "ignore", "pipe"],
+        windowsHide: true
+      });
+      const tunnel = new _Tunnel(options, localPort, child);
+      try {
+        await tunnel.#awaitReady();
+        return tunnel;
+      } catch (error) {
+        lastError = error;
+        await tunnel.stop();
+      }
+    }
+    throw lastError instanceof LocalError ? lastError : new LocalError("ssh/tunnel-failed", `could not establish SSH tunnel to ${options.target.canonical}`, {
+      cause: lastError,
+      retryable: true
+    });
+  }
+  /** Child process id. */
+  get pid() {
+    return this.#child.pid;
+  }
+  /** Captured stderr tail. */
+  get stderr() {
+    return Buffer.concat(this.#stderr).toString("utf8").trim();
+  }
+  /** Stop the tunnel; idempotent. */
+  async stop() {
+    if (this.#stopping) return;
+    this.#stopping = true;
+    if (this.#exited) return;
+    this.#child.kill("SIGTERM");
+    const exited = await waitForExit(this.#child, 2e3);
+    if (!exited) {
+      this.#child.kill("SIGKILL");
+      await waitForExit(this.#child, 1e3);
+    }
+  }
+  async #awaitReady() {
+    const exited = new Promise((_, reject) => {
+      this.#child.once("error", (error) => {
+        reject(new LocalError("ssh/tunnel-failed", `SSH tunnel failed to spawn: ${String(error)}`, { cause: error }));
+      });
+      this.#child.once("exit", (code, signal) => {
+        if (this.#stopping) return;
+        const detail = this.stderr;
+        reject(new LocalError("ssh/tunnel-failed", [
+          `SSH tunnel exited before it was ready (code ${String(code)}, signal ${String(signal)})`,
+          detail === "" ? "" : `: ${detail.split("\n")[0]}`
+        ].join("")));
+      });
+    });
+    await Promise.race([
+      waitForPort(this.localPort, this.#options.connectTimeoutMs),
+      exited
+    ]);
+    if (this.#exited) {
+      throw new LocalError("ssh/tunnel-failed", `SSH tunnel exited immediately: ${this.stderr.split("\n")[0] ?? "unknown error"}`);
+    }
+  }
+};
+function waitForExit(child, timeoutMs) {
+  return new Promise((resolve4) => {
+    if (child.exitCode !== null || child.signalCode !== null) {
+      resolve4(true);
+      return;
+    }
+    const timer = setTimeout(() => resolve4(false), timeoutMs);
+    timer.unref?.();
+    child.once("exit", () => {
+      clearTimeout(timer);
+      resolve4(true);
+    });
+  });
+}
+
+// src/service.ts
+function fingerprintKey(value) {
+  return createHash3("sha256").update(value).digest("hex");
+}
+var RemoteHostsService = class {
+  ctx;
+  config;
+  #store;
+  #provisioner;
+  #resolveModelKey;
+  #proxy;
+  #proxyAddress;
+  #directModel;
+  #directModelAttempted = false;
+  #modelReconciled = /* @__PURE__ */ new Set();
+  #records = /* @__PURE__ */ new Map();
+  #runtime = /* @__PURE__ */ new Map();
+  #tunnels = /* @__PURE__ */ new Map();
+  #clients = /* @__PURE__ */ new Map();
+  #connectPromises = /* @__PURE__ */ new Map();
+  #healthTimers = /* @__PURE__ */ new Map();
+  #reconnectTimers = /* @__PURE__ */ new Map();
+  #healthInFlight = /* @__PURE__ */ new Set();
+  #attempts = /* @__PURE__ */ new Map();
+  #manualDisconnect = /* @__PURE__ */ new Set();
+  #disposed = false;
+  constructor(ctx, config, options = {}) {
+    this.ctx = ctx;
+    this.config = config;
+    this.#store = new HostStore(`${config.stateDir}/hosts.json`);
+    this.#provisioner = new RemoteProvisioner(config);
+    this.#resolveModelKey = options.resolveModelKey;
+  }
+  /** Load the registry and auto-connect opted-in hosts. */
+  async start() {
+    const loaded = await this.#store.load();
+    for (const warning of loaded.warnings) this.ctx.logger.warn("dsh-remote: %s", warning);
+    for (const record of loaded.hosts) {
+      this.#records.set(record.id, record);
+      this.#runtime.set(record.id, idleRuntime());
+    }
+    for (const record of loaded.hosts) {
+      if (!record.autoConnect) continue;
+      this.#manualDisconnect.delete(record.id);
+      this.#setRuntime(record.id, { phase: "idle" });
+      void this.connect(record.id).catch((error) => {
+        this.ctx.logger.warn("dsh-remote: auto-connect %s failed: %s", record.id, String(error));
+      });
+    }
+  }
+  /** Browser/tool snapshot. */
+  state() {
+    return { protocolVersion: PROTOCOL_VERSION, hosts: this.list() };
+  }
+  /** All hosts in creation order. */
+  list() {
+    return [...this.#records.values()].sort((left, right) => left.createdAt.localeCompare(right.createdAt)).map((record) => this.view(record.id));
+  }
+  /** One host view. */
+  view(id) {
+    const record = this.#requireRecord(id);
+    return toHostView(record, this.#runtime.get(id) ?? idleRuntime());
+  }
+  /** Parse a destination without touching SSH. */
+  validateTarget(raw) {
+    const target = parseSshTarget(raw);
+    return { canonical: target.canonical, host: target.host, user: target.user, port: target.port };
+  }
+  /** Register a host and (by default) start connecting in the background. */
+  async add(input) {
+    this.#assertAlive();
+    const target = parseSshTarget(input.sshTarget);
+    if (this.#records.has(hostIdFor(target.canonical, input.label))) {
+      throw new LocalError("host/duplicate", `host ${target.canonical} already exists`);
+    }
+    if ([...this.#records.values()].some((record2) => record2.sshTarget === target.canonical)) {
+      throw new LocalError("host/duplicate", `host ${target.canonical} already exists`);
+    }
+    if (input.token !== void 0 && input.token.trim() !== "" && input.token.trim().length < 16) {
+      throw new LocalError("host/invalid", "agent token must be at least 16 characters");
+    }
+    if (input.remoteAgentPort !== void 0 && (!Number.isInteger(input.remoteAgentPort) || input.remoteAgentPort < 1 || input.remoteAgentPort > 65535)) {
+      throw new LocalError("host/invalid", "remote agent port must be between 1 and 65535");
+    }
+    const label = validateHostLabel(input.label ?? target.host);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const record = {
+      id: hostIdFor(target.canonical, label),
+      label,
+      sshTarget: target.canonical,
+      sshPort: target.port,
+      remoteAgentPort: input.remoteAgentPort ?? null,
+      token: input.token === void 0 || input.token.trim() === "" ? null : input.token.trim(),
+      autoConnect: input.autoConnect ?? true,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.#store.add(record);
+    this.#records.set(record.id, record);
+    this.#runtime.set(record.id, idleRuntime());
+    this.#manualDisconnect.delete(record.id);
+    if (record.autoConnect) {
+      this.#setRuntime(record.id, { phase: "discovering" });
+      void this.connect(record.id).catch((error) => {
+        this.ctx.logger.warn("dsh-remote: connect %s failed: %s", record.id, String(error));
+      });
+    }
+    return this.view(record.id);
+  }
+  /** Remove a host and tear down its tunnel. */
+  async remove(id) {
+    this.#assertAlive();
+    this.#requireRecord(id);
+    this.#manualDisconnect.add(id);
+    this.#clearReconnect(id);
+    await this.#stopTransport(id);
+    await this.#store.remove(id);
+    this.#records.delete(id);
+    this.#runtime.delete(id);
+    this.#attempts.delete(id);
+    this.#manualDisconnect.delete(id);
+  }
+  /** Connect one host, waiting for discovery, tunnel, and health. */
+  async connect(id) {
+    this.#assertAlive();
+    this.#requireRecord(id);
+    const existing = this.#connectPromises.get(id);
+    if (existing !== void 0) return existing;
+    const promise = this.#doConnect(id).finally(() => {
+      this.#connectPromises.delete(id);
+    });
+    this.#connectPromises.set(id, promise);
+    return promise;
+  }
+  /** Disconnect one host and suppress automatic reconnection. */
+  async disconnect(id) {
+    this.#assertAlive();
+    this.#requireRecord(id);
+    this.#manualDisconnect.add(id);
+    this.#clearReconnect(id);
+    await this.#stopTransport(id);
+    this.#attempts.delete(id);
+    this.#setRuntime(id, {
+      phase: "disconnected",
+      localPort: null,
+      localUrl: null,
+      hostInfo: null,
+      workspaceCount: null,
+      error: null,
+      errorCode: null,
+      connectedAt: null
+    });
+    return this.view(id);
+  }
+  /** Re-discover the remote agent; reconnect when its port or token changed. */
+  async refresh(id) {
+    this.#assertAlive();
+    const record = this.#requireRecord(id);
+    const connected = this.#connected(id);
+    if (connected === void 0) return this.connect(id);
+    const target = parseSshTarget(record.sshTarget);
+    const discovery = await this.#discover(target);
+    if (discovery.state.port !== record.remoteAgentPort || discovery.state.token !== record.token) {
+      await this.#saveRecord(id, {
+        remoteAgentPort: discovery.state.port,
+        token: discovery.state.token
+      });
+      return this.connect(id);
+    }
+    const health = await connected.client.health();
+    this.#setConnected(id, health);
+    return this.view(id);
+  }
+  /** Force a fresh remote install/restart, then reconnect. */
+  async provision(id) {
+    this.#assertAlive();
+    const record = this.#requireRecord(id);
+    const target = parseSshTarget(record.sshTarget);
+    this.#manualDisconnect.delete(id);
+    this.#clearReconnect(id);
+    await this.#stopTransport(id);
+    const proxy = await this.#ensureModelProxy();
+    const proxyToken = proxy === void 0 ? void 0 : await this.#ensureProxyToken(id);
+    const direct = proxy === void 0 ? await this.#ensureDirectModel() : void 0;
+    this.#setRuntime(id, {
+      ...idleRuntime(),
+      phase: "installing",
+      modelProxy: proxy !== void 0,
+      modelDirect: direct !== void 0,
+      detail: "\u6B63\u5728\u91CD\u65B0\u5B89\u88C5\u8FDC\u7AEF agent\u2026"
+    });
+    try {
+      await this.#provisioner.ensureInstalled(target, {
+        ...this.#modelEnvironment(proxy, proxyToken, direct),
+        onProgress: (detail) => this.#setRuntime(id, { ...this.#runtimeFor(id), detail })
+      });
+    } catch (error) {
+      const failure = this.#markError(id, error, "agent/unavailable");
+      this.#scheduleReconnect(id);
+      throw failure;
+    }
+    return this.connect(id);
+  }
+  /** List remote workspaces. */
+  async workspaces(id) {
+    const client = this.#requireClient(id);
+    try {
+      const workspaces = await client.listWorkspaces();
+      this.#setRuntime(id, { workspaceCount: workspaces.length, error: null, errorCode: null });
+      return workspaces;
+    } catch (error) {
+      throw this.#remoteFailure(id, error);
+    }
+  }
+  /** List remote sessions, optionally within one workspace. */
+  async sessions(id, workspaceId) {
+    const client = this.#requireClient(id);
+    try {
+      const sessions = await client.listSessions(workspaceId);
+      return { sessions };
+    } catch (error) {
+      throw this.#remoteFailure(id, error);
+    }
+  }
+  /** Read one session snapshot. */
+  async snapshot(id, sessionId, limit) {
+    const client = this.#requireClient(id);
+    try {
+      return await client.snapshotSession(sessionId, limit === void 0 ? {} : { limit });
+    } catch (error) {
+      throw this.#remoteFailure(id, error);
+    }
+  }
+  /** Register a remote workspace. */
+  async createWorkspace(id, request) {
+    const client = this.#requireClient(id);
+    try {
+      const workspace = await client.createWorkspace(request);
+      this.#setRuntime(id, { workspaceCount: (this.#runtimeFor(id).workspaceCount ?? 0) + 1 });
+      return workspace;
+    } catch (error) {
+      throw this.#remoteFailure(id, error);
+    }
+  }
+  /** Create a remote session. */
+  async createSession(id, request) {
+    const client = this.#requireClient(id);
+    try {
+      return await client.createSession(request);
+    } catch (error) {
+      throw this.#remoteFailure(id, error);
+    }
+  }
+  /** Send a prompt to a remote session. */
+  async promptSession(id, sessionId, text, mode, selection) {
+    const client = this.#requireClient(id);
+    try {
+      await client.promptSession(sessionId, {
+        text,
+        ...mode === void 0 ? {} : { mode },
+        ...selection === void 0 ? {} : selection
+      });
+      return { accepted: true };
+    } catch (error) {
+      throw this.#remoteFailure(id, error);
+    }
+  }
+  /** Cancel a remote session's active turn. */
+  async cancelSession(id, sessionId) {
+    const client = this.#requireClient(id);
+    try {
+      await client.cancelSession(sessionId);
+      return { accepted: true };
+    } catch (error) {
+      throw this.#remoteFailure(id, error);
+    }
+  }
+  /** SSH invocation facts for auxiliary remote file/terminal adapters. */
+  sshFor(id) {
+    const record = this.#requireRecord(id);
+    const target = parseSshTarget(record.sshTarget);
+    return { binary: this.config.sshBinary, target: target.destination, port: target.port };
+  }
+  /** Follow remote approval questions for one host. */
+  async *followApprovals(id, signal) {
+    const client = this.#requireClient(id);
+    try {
+      yield* client.followApprovals(signal);
+    } catch (error) {
+      throw this.#remoteFailure(id, error);
+    }
+  }
+  /** Send one approval answer to the remote agent. */
+  async answerApproval(id, approvalId, outcome) {
+    const client = this.#requireClient(id);
+    try {
+      return await client.answerApproval(approvalId, outcome);
+    } catch (error) {
+      throw this.#remoteFailure(id, error);
+    }
+  }
+  /** Resolve the remote Web UI behind this host's tunnel. */
+  async webUrl(id) {
+    const client = this.#requireClient(id);
+    const connected = this.#connected(id);
+    if (connected === void 0) throw new LocalError("host/not-connected", `host ${id} is not connected`);
+    let path;
+    try {
+      path = await client.webUrl();
+    } catch (error) {
+      throw this.#remoteFailure(id, error);
+    }
+    return { url: `${connected.tunnel.localUrl}${path.path}` };
+  }
+  /** Stop every tunnel and timer. */
+  async dispose() {
+    if (this.#disposed) return;
+    this.#disposed = true;
+    for (const id of [...this.#healthTimers.keys()]) this.#clearHealth(id);
+    for (const id of [...this.#reconnectTimers.keys()]) this.#clearReconnect(id);
+    await Promise.all([...this.#tunnels.keys()].map((id) => this.#stopTransport(id)));
+    await this.#proxy?.stop();
+    this.#proxy = void 0;
+    this.#proxyAddress = void 0;
+    this.#directModel = void 0;
+    this.#directModelAttempted = false;
+    this.#records.clear();
+    this.#runtime.clear();
+    this.#connectPromises.clear();
+  }
+  async #doConnect(id) {
+    this.#assertAlive();
+    const record = this.#requireRecord(id);
+    this.#manualDisconnect.delete(id);
+    this.#clearReconnect(id);
+    await this.#stopTransport(id);
+    this.#setRuntime(id, {
+      ...idleRuntime(),
+      phase: "discovering",
+      detail: "\u6B63\u5728\u901A\u8FC7 SSH \u53D1\u73B0\u8FDC\u7AEF agent\u2026"
+    });
+    const target = parseSshTarget(record.sshTarget);
+    const proxy = await this.#ensureModelProxy();
+    const proxyToken = proxy === void 0 ? void 0 : await this.#ensureProxyToken(id);
+    const direct = proxy === void 0 ? await this.#ensureDirectModel() : void 0;
+    this.#setRuntime(id, {
+      ...this.#runtimeFor(id),
+      modelProxy: proxy !== void 0,
+      modelDirect: direct !== void 0
+    });
+    const reverseForward = proxy === void 0 ? void 0 : { remotePort: this.config.credentialProxyRemotePort, localPort: proxy.port };
+    let remotePort = record.remoteAgentPort;
+    let token = record.token;
+    try {
+      const discovery = await this.#discover(target);
+      remotePort = discovery.state.port;
+      token = discovery.state.token;
+      if (remotePort === null) {
+        throw new LocalError("agent/unavailable", "remote agent has no active listener port");
+      }
+      await this.#saveRecord(id, { remoteAgentPort: remotePort, token });
+    } catch (error) {
+      const failure = asLocalError(error, "ssh/probe-failed");
+      if (this.config.autoProvision && failure.code === "agent/unavailable") {
+        this.#setRuntime(id, {
+          ...this.#runtimeFor(id),
+          phase: "installing",
+          detail: "\u6B63\u5728\u8FDC\u7AEF\u5B89\u88C5 DSH \u4E0E dsh-remote-agent\uFF0C\u9996\u6B21\u7EA6 1\u20133 \u5206\u949F\u2026"
+        });
+        try {
+          await this.#provisioner.ensureInstalled(target, {
+            ...this.#modelEnvironment(proxy, proxyToken, direct),
+            onProgress: (detail) => this.#setRuntime(id, { ...this.#runtimeFor(id), detail })
+          });
+          const discovery = await this.#discover(target);
+          remotePort = discovery.state.port;
+          token = discovery.state.token;
+          await this.#saveRecord(id, { remoteAgentPort: remotePort, token });
+        } catch (provisionError) {
+          const provisionFailure = this.#markError(id, provisionError, "agent/unavailable");
+          this.#scheduleReconnect(id);
+          throw provisionFailure;
+        }
+      } else if (token !== null && remotePort !== null) {
+        this.ctx.logger.warn(
+          "dsh-remote: discovery for %s failed; using cached port %s: %s",
+          id,
+          String(remotePort),
+          String(error)
+        );
+      } else {
+        const marked = this.#markError(id, error, failure.code);
+        this.#scheduleReconnect(id);
+        throw marked;
+      }
+    }
+    if (remotePort === null || token === null) {
+      const failure = this.#markError(
+        id,
+        new LocalError("agent/unavailable", "no remote agent token or port is available"),
+        "agent/unavailable"
+      );
+      this.#scheduleReconnect(id);
+      throw failure;
+    }
+    this.#setRuntime(id, {
+      ...this.#runtimeFor(id),
+      phase: "connecting",
+      detail: "\u6B63\u5728\u5EFA\u7ACB SSH \u96A7\u9053\u5E76\u6821\u9A8C\u8FDC\u7AEF agent\u2026"
+    });
+    let tunnel;
+    try {
+      tunnel = await Tunnel.start({
+        sshBinary: this.config.sshBinary,
+        target,
+        remotePort,
+        connectTimeoutMs: this.config.connectTimeoutMs,
+        strictHostKeyChecking: this.config.strictHostKeyChecking,
+        ...reverseForward === void 0 ? {} : { reverseForward },
+        onExit: (info) => this.#onTunnelExit(id, info)
+      });
+      const client = new RemoteAgentClient({
+        baseUrl: tunnel.localUrl,
+        token,
+        hostId: id
+      });
+      const health = await client.health();
+      if (await this.#reconcileModelEnvironment(id, target, health, proxy, proxyToken, direct, tunnel)) {
+        return this.#doConnect(id);
+      }
+      this.#tunnels.set(id, tunnel);
+      this.#clients.set(id, client);
+      this.#setConnected(id, health);
+      this.#startHealthTimer(id);
+      this.#attempts.delete(id);
+      return this.view(id);
+    } catch (error) {
+      await tunnel?.stop();
+      const failure = this.#markError(id, error, "host/connect-failed");
+      this.#scheduleReconnect(id);
+      throw failure;
+    }
+  }
+  async #reconcileModelEnvironment(id, target, health, proxy, proxyToken, direct, tunnel) {
+    const desired = proxy === void 0 ? direct?.baseUrl : `http://127.0.0.1:${this.config.credentialProxyRemotePort}`;
+    if (desired === void 0) return false;
+    const current = health.modelBaseUrl?.replace(/\/+$/u, "") ?? null;
+    const expectedKey = proxy === void 0 ? direct?.apiKey : proxyToken;
+    const matches = current === desired.replace(/\/+$/u, "") && expectedKey !== void 0 && health.modelKeyFingerprint === fingerprintKey(expectedKey);
+    if (matches) {
+      this.#modelReconciled.delete(id);
+      return false;
+    }
+    if (this.#modelReconciled.has(id) || !this.config.autoProvision) {
+      this.ctx.logger.warn(
+        "dsh-remote: model environment for %s still differs from this profile (%s vs %s)",
+        id,
+        current ?? "unset",
+        desired
+      );
+      return false;
+    }
+    this.#modelReconciled.add(id);
+    this.ctx.logger.warn(
+      "dsh-remote: remote model environment for %s is %s, expected %s; reinstalling",
+      id,
+      current ?? "unset",
+      desired
+    );
+    await tunnel.stop();
+    try {
+      await this.#provisioner.ensureInstalled(target, {
+        ...this.#modelEnvironment(proxy, proxyToken, direct),
+        onProgress: (detail) => this.#setRuntime(id, { ...this.#runtimeFor(id), detail })
+      });
+    } catch (error) {
+      this.#modelReconciled.delete(id);
+      throw error;
+    }
+    return true;
+  }
+  async #ensureDirectModel() {
+    if (this.config.credentialProxy || !this.config.copyModelKey) return void 0;
+    if (this.#directModelAttempted) return this.#directModel;
+    this.#directModelAttempted = true;
+    let key2;
+    try {
+      key2 = await this.#resolveModelKey?.();
+    } catch (error) {
+      this.ctx.logger.warn("dsh-remote: could not resolve local model credential: %s", String(error));
+      return void 0;
+    }
+    if (key2 === void 0 || key2.trim() === "") {
+      this.ctx.logger.warn("dsh-remote: no local DEEPSEEK_API_KEY; remote host must use its own credentials");
+      return void 0;
+    }
+    this.#directModel = { baseUrl: this.config.remoteModelBaseUrl, apiKey: key2 };
+    return this.#directModel;
+  }
+  #modelEnvironment(proxy, proxyToken, direct) {
+    if (proxy !== void 0) {
+      if (proxyToken === void 0) throw new LocalError("internal", "credential proxy token is unavailable");
+      return {
+        modelBaseUrl: `http://127.0.0.1:${this.config.credentialProxyRemotePort}`,
+        modelApiKey: proxyToken
+      };
+    }
+    if (direct !== void 0) return { modelBaseUrl: direct.baseUrl, modelApiKey: direct.apiKey };
+    return {};
+  }
+  async #ensureProxyToken(id) {
+    const record = this.#requireRecord(id);
+    if (typeof record.proxyToken === "string" && record.proxyToken.length >= 16) return record.proxyToken;
+    const token = randomBytes(32).toString("hex");
+    await this.#saveRecord(id, { proxyToken: token });
+    return token;
+  }
+  #isProxyToken(token) {
+    const presented = Buffer.from(token, "utf8");
+    for (const record of this.#records.values()) {
+      const expected = record.proxyToken;
+      if (typeof expected !== "string") continue;
+      const candidate = Buffer.from(expected, "utf8");
+      if (candidate.length === presented.length && timingSafeEqual(candidate, presented)) return true;
+    }
+    return false;
+  }
+  async #ensureModelProxy() {
+    if (!this.config.credentialProxy) return void 0;
+    if (this.#proxyAddress !== void 0) return this.#proxyAddress;
+    let key2;
+    try {
+      key2 = await this.#resolveModelKey?.();
+    } catch (error) {
+      this.ctx.logger.warn("dsh-remote: could not resolve local model credential: %s", String(error));
+      return void 0;
+    }
+    if (key2 === void 0 || key2.trim() === "") {
+      this.ctx.logger.warn("dsh-remote: no local DEEPSEEK_API_KEY; remote host must use its own credentials");
+      return void 0;
+    }
+    try {
+      const proxy = new ModelCredentialProxy({
+        apiKey: key2,
+        upstreamBaseUrl: this.config.credentialProxyUpstream,
+        isTokenValid: (token) => this.#isProxyToken(token)
+      });
+      const address = await proxy.start();
+      this.#proxy = proxy;
+      this.#proxyAddress = address;
+      return address;
+    } catch (error) {
+      this.ctx.logger.warn("dsh-remote: could not start credential proxy: %s", String(error));
+      return void 0;
+    }
+  }
+  async #discover(target) {
+    return discoverAgent(target, {
+      sshBinary: this.config.sshBinary,
+      timeoutMs: this.config.probeTimeoutMs,
+      strictHostKeyChecking: this.config.strictHostKeyChecking,
+      remoteStateFile: this.config.remoteStateFile
+    });
+  }
+  #onTunnelExit(id, info) {
+    if (this.#disposed || this.#manualDisconnect.has(id)) return;
+    this.#clients.delete(id);
+    this.#tunnels.delete(id);
+    this.#clearHealth(id);
+    const detail = info.stderr === "" ? "" : `: ${info.stderr.split("\n")[0]}`;
+    this.#setRuntime(id, {
+      ...this.#runtimeFor(id),
+      phase: "error",
+      localPort: null,
+      localUrl: null,
+      error: `SSH tunnel exited (code ${String(info.code)}, signal ${String(info.signal)})${detail}`,
+      errorCode: "ssh/tunnel-failed",
+      detail: "SSH \u96A7\u9053\u65AD\u5F00\uFF0C\u7B49\u5F85\u91CD\u8FDE\u2026"
+    });
+    this.#scheduleReconnect(id);
+  }
+  #startHealthTimer(id) {
+    this.#clearHealth(id);
+    const timer = setInterval(() => {
+      void this.#healthCheck(id);
+    }, this.config.healthIntervalMs);
+    timer.unref?.();
+    this.#healthTimers.set(id, timer);
+  }
+  async #healthCheck(id) {
+    if (this.#disposed || this.#healthInFlight.has(id)) return;
+    const client = this.#clients.get(id);
+    if (client === void 0) return;
+    this.#healthInFlight.add(id);
+    try {
+      const health = await client.health();
+      this.#setConnected(id, health);
+    } catch (error) {
+      this.ctx.logger.warn("dsh-remote: health check %s failed: %s", id, String(error));
+      const connected = this.#connected(id);
+      await connected?.tunnel.stop();
+      this.#tunnels.delete(id);
+      this.#clients.delete(id);
+      this.#clearHealth(id);
+      this.#markError(id, error, "agent/unavailable");
+      this.#scheduleReconnect(id);
+    } finally {
+      this.#healthInFlight.delete(id);
+    }
+  }
+  #scheduleReconnect(id) {
+    if (this.#disposed || !this.config.reconnect || this.#manualDisconnect.has(id)) return;
+    if (this.#reconnectTimers.has(id)) return;
+    if (!this.#records.has(id)) return;
+    const attempt = (this.#attempts.get(id) ?? 0) + 1;
+    this.#attempts.set(id, attempt);
+    const delay = Math.min(1e3 * 2 ** Math.min(attempt - 1, 10), this.config.maxReconnectDelayMs);
+    this.ctx.logger.info("dsh-remote: reconnecting %s in %dms (attempt %d)", id, delay, attempt);
+    const timer = setTimeout(() => {
+      this.#reconnectTimers.delete(id);
+      void this.connect(id).catch((error) => {
+        this.ctx.logger.warn("dsh-remote: reconnect %s failed: %s", id, String(error));
+      });
+    }, delay);
+    timer.unref?.();
+    this.#reconnectTimers.set(id, timer);
+  }
+  #clearReconnect(id) {
+    const timer = this.#reconnectTimers.get(id);
+    if (timer !== void 0) clearTimeout(timer);
+    this.#reconnectTimers.delete(id);
+  }
+  #clearHealth(id) {
+    const timer = this.#healthTimers.get(id);
+    if (timer !== void 0) clearInterval(timer);
+    this.#healthTimers.delete(id);
+  }
+  async #stopTransport(id) {
+    this.#clearHealth(id);
+    const tunnel = this.#tunnels.get(id);
+    this.#tunnels.delete(id);
+    this.#clients.delete(id);
+    await tunnel?.stop();
+  }
+  #requireRecord(id) {
+    const record = this.#records.get(id);
+    if (record === void 0) throw new LocalError("host/not-found", `host ${id} does not exist`);
+    return record;
+  }
+  #connected(id) {
+    const record = this.#records.get(id);
+    const tunnel = this.#tunnels.get(id);
+    const client = this.#clients.get(id);
+    if (record === void 0 || tunnel === void 0 || client === void 0) return void 0;
+    return { record, target: parseSshTarget(record.sshTarget), tunnel, client };
+  }
+  #requireClient(id) {
+    const client = this.#clients.get(id);
+    if (client === void 0 || this.#runtime.get(id)?.phase !== "connected") {
+      throw new LocalError("host/not-connected", `host ${id} is not connected; connect it first`);
+    }
+    return client;
+  }
+  #runtimeFor(id) {
+    return this.#runtime.get(id) ?? idleRuntime();
+  }
+  #setRuntime(id, patch) {
+    this.#runtime.set(id, { ...this.#runtimeFor(id), ...patch });
+  }
+  #setConnected(id, health) {
+    const existing = this.#connected(id);
+    this.#setRuntime(id, {
+      phase: "connected",
+      localPort: existing?.tunnel.localPort ?? this.#runtimeFor(id).localPort,
+      localUrl: existing?.tunnel.localUrl ?? this.#runtimeFor(id).localUrl,
+      hostInfo: health,
+      workspaceCount: health.workspaceCount,
+      error: null,
+      errorCode: null,
+      connectedAt: this.#runtimeFor(id).connectedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      detail: this.#runtimeFor(id).modelProxy ? "\u5DF2\u8FDE\u63A5\uFF1B\u6A21\u578B\u8BF7\u6C42\u7ECF\u672C\u5730\u51ED\u636E\u4EE3\u7406\u8F6C\u53D1" : this.#runtimeFor(id).modelDirect ? "\u5DF2\u8FDE\u63A5\uFF1B\u6A21\u578B\u8BF7\u6C42\u7531\u8FDC\u7AEF\u76F4\u8FDE DeepSeek" : "\u5DF2\u8FDE\u63A5\uFF1B\u8FDC\u7AEF\u4F7F\u7528\u81EA\u8EAB\u51ED\u636E\u6216\u672A\u914D\u7F6E\u6A21\u578B key"
+    });
+  }
+  async #saveRecord(id, patch) {
+    const record = this.#requireRecord(id);
+    const next = { ...record, ...patch, id, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await this.#store.update(id, next);
+    this.#records.set(id, next);
+  }
+  #markError(id, error, fallback) {
+    const failure = asLocalError(error, fallback);
+    this.#setRuntime(id, {
+      ...this.#runtimeFor(id),
+      phase: "error",
+      localPort: null,
+      localUrl: null,
+      error: failure.message,
+      errorCode: failure.code,
+      detail: failure.message
+    });
+    return failure;
+  }
+  #remoteFailure(id, error) {
+    if (error instanceof LocalError) return error;
+    if (error instanceof RemoteProtocolError) {
+      const failure2 = new LocalError("agent/error", `remote agent: ${error.message}`, {
+        details: { remoteCode: error.code, ...error.details },
+        retryable: error.retryable,
+        cause: error
+      });
+      this.#setRuntime(id, { error: failure2.message, errorCode: failure2.code });
+      return failure2;
+    }
+    const failure = new LocalError("agent/unavailable", "remote agent request failed", { cause: error });
+    this.#setRuntime(id, { error: failure.message, errorCode: failure.code });
+    return failure;
+  }
+  #assertAlive() {
+    if (this.#disposed) throw new LocalError("internal", "remote host service is disposed");
+  }
+};
+
+// src/tools.ts
+import { defineTool } from "@deepseek-ai/dsh-tools";
+var renderJson = (_args, value) => [
+  { type: "text", text: JSON.stringify(value, null, 2) }
+];
+function toJsonObject(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+var HOST_WRITE_TOOLS = /* @__PURE__ */ new Set(["remote_host_add", "remote_host_connect", "remote_host_provision"]);
+function installRemoteToolGuards(ctx) {
+  ctx.effect(() => ctx.on("tools/pre-execute", (exec, next) => {
+    if (!HOST_WRITE_TOOLS.has(exec.name)) return next();
+    return Promise.resolve({
+      kind: "ask",
+      reason: `remote host write: ${exec.name}`,
+      displayReason: {
+        en: "Allow this remote-host operation? It may open an SSH connection and copy the local model credential to the remote host.",
+        zh: "\u5141\u8BB8\u8FD9\u6B21\u8FDC\u7A0B\u4E3B\u673A\u64CD\u4F5C\u5417\uFF1F\u5B83\u53EF\u80FD\u901A\u8FC7 SSH \u8FDE\u63A5\uFF0C\u5E76\u628A\u672C\u5730\u6A21\u578B\u51ED\u636E\u590D\u5236\u5230\u8FDC\u7AEF\u4E3B\u673A\u3002"
+      }
+    });
+  }), "dsh-remote-local: host-write tool approvals");
+}
+function registerRemoteTools(ctx, service) {
+  ctx.tools.register(defineTool({
+    name: "remote_hosts_list",
+    description: "List configured remote development hosts, their SSH destinations, connection phases, and remote host facts. Use this before connecting or listing remote workspaces.",
+    parameters: {},
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          protocolVersion: { type: "number", required: true },
+          hosts: { type: "array", required: true, items: { type: "object", additionalProperties: true } }
+        }
+      },
+      render: renderJson
+    },
+    async execute() {
+      const state = service.state();
+      return { protocolVersion: state.protocolVersion, hosts: state.hosts.map(toJsonObject) };
+    }
+  }));
+  ctx.tools.register(defineTool({
+    name: "remote_host_add",
+    description: "Register an SSH host for remote development. The local plugin discovers the remote agent over SSH and opens a loopback SSH tunnel. The token is optional when discovery succeeds; never paste a token into chat unless you control it.",
+    parameters: {
+      sshTarget: {
+        type: "string",
+        required: true,
+        description: "SSH destination such as user@host, host:2222, or ssh://user@host:22."
+      },
+      label: { type: "string", description: "Display label; defaults to the hostname." },
+      token: { type: "string", description: "Optional remote agent bearer token. Prefer discovery." },
+      remoteAgentPort: { type: "number", description: "Optional remote agent port when discovery is unavailable." },
+      autoConnect: { type: "boolean", description: "Connect immediately. Agent tool calls default to false and require approval." }
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          host: { type: "object", additionalProperties: true, required: true }
+        }
+      },
+      render: renderJson
+    },
+    async execute(args) {
+      return { host: toJsonObject(await service.add({ ...args, autoConnect: args.autoConnect ?? false })) };
+    }
+  }));
+  ctx.tools.register(defineTool({
+    name: "remote_host_connect",
+    description: "Connect, reconnect, or refresh one registered remote host. Waits for SSH discovery, the tunnel, and the remote agent health check to settle.",
+    parameters: {
+      hostId: { type: "string", required: true, description: "Host id returned by remote_hosts_list or remote_host_add." }
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          host: { type: "object", additionalProperties: true, required: true }
+        }
+      },
+      render: renderJson
+    },
+    async execute(args) {
+      return { host: toJsonObject(await service.connect(args.hostId)) };
+    }
+  }));
+  ctx.tools.register(defineTool({
+    name: "remote_host_provision",
+    description: "Force a fresh remote installation/restart of dsh-remote-agent and dsh web, then reconnect. Use this to repair a broken host or update an old agent.",
+    parameters: {
+      hostId: { type: "string", required: true, description: "Registered host id." }
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: { host: { type: "object", additionalProperties: true, required: true } }
+      },
+      render: renderJson
+    },
+    async execute(args) {
+      return { host: toJsonObject(await service.provision(args.hostId)) };
+    }
+  }));
+  ctx.tools.register(defineTool({
+    name: "remote_workspaces_list",
+    description: "List workspaces registered on a connected remote DSH host. Use the returned workspaceId with remote_sessions_list.",
+    parameters: {
+      hostId: { type: "string", required: true, description: "Connected remote host id." }
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          workspaces: { type: "array", required: true, items: { type: "object", additionalProperties: true } }
+        }
+      },
+      render: renderJson
+    },
+    async execute(args) {
+      return { workspaces: (await service.workspaces(args.hostId)).map(toJsonObject) };
+    }
+  }));
+  ctx.tools.register(defineTool({
+    name: "remote_workspace_add",
+    description: "Register an existing remote directory as a workspace on a connected remote DSH host. Then create a session in it with remote_session_create.",
+    parameters: {
+      hostId: { type: "string", required: true, description: "Connected remote host id." },
+      path: { type: "string", required: true, description: "Absolute remote directory path." },
+      title: { type: "string", description: "Optional display title." }
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          workspace: { type: "object", additionalProperties: true, required: true }
+        }
+      },
+      render: renderJson
+    },
+    async execute(args) {
+      return { workspace: toJsonObject(await service.createWorkspace(args.hostId, {
+        path: args.path,
+        ...args.title === void 0 ? {} : { title: args.title }
+      })) };
+    }
+  }));
+  ctx.tools.register(defineTool({
+    name: "remote_sessions_list",
+    description: "List sessions on a connected remote DSH host, optionally scoped to one workspace. Includes live/persisted state and event counts when available.",
+    parameters: {
+      hostId: { type: "string", required: true, description: "Connected remote host id." },
+      workspaceId: { type: "string", description: "Optional remote workspace id." }
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          sessions: { type: "array", required: true, items: { type: "object", additionalProperties: true } }
+        }
+      },
+      render: renderJson
+    },
+    async execute(args) {
+      const { sessions } = await service.sessions(args.hostId, args.workspaceId);
+      return { sessions: sessions.map(toJsonObject) };
+    }
+  }));
+  ctx.tools.register(defineTool({
+    name: "remote_session_snapshot",
+    description: "Read the newest page of one remote session event log. This is a read-only projection; no tool executes on the remote host.",
+    parameters: {
+      hostId: { type: "string", required: true, description: "Connected remote host id." },
+      sessionId: { type: "string", required: true, description: "Remote session id." },
+      limit: { type: "number", description: "Maximum events to return (default 500, capped by the agent)." }
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          snapshot: { type: "object", additionalProperties: true, required: true }
+        }
+      },
+      render: renderJson
+    },
+    async execute(args) {
+      return { snapshot: toJsonObject(await service.snapshot(args.hostId, args.sessionId, args.limit)) };
+    }
+  }));
+  ctx.tools.register(defineTool({
+    name: "remote_session_create",
+    description: "Create a session on a connected remote DSH host, either in an existing workspace or an explicit remote directory. This is a write operation on the remote host.",
+    parameters: {
+      hostId: { type: "string", required: true, description: "Connected remote host id." },
+      workspaceId: { type: "string", description: "Existing remote workspace id." },
+      cwd: { type: "string", description: "Remote directory for an ungrouped session; exclusive with workspaceId." },
+      agentPreset: { type: "string", description: "Optional remote agent preset." }
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          sessionId: { type: "string", required: true },
+          agentPreset: { type: "string" }
+        }
+      },
+      render: renderJson
+    },
+    async execute(args) {
+      return service.createSession(args.hostId, {
+        ...args.workspaceId === void 0 ? {} : { workspaceId: args.workspaceId },
+        ...args.cwd === void 0 ? {} : { cwd: args.cwd },
+        ...args.agentPreset === void 0 ? {} : { agentPreset: args.agentPreset }
+      });
+    }
+  }));
+  ctx.tools.register(defineTool({
+    name: "remote_session_prompt",
+    description: "Send a user prompt to a remote DSH session. The remote model runs on the remote host; the local model key can be proxied through the local credential proxy. This is a write operation.",
+    parameters: {
+      hostId: { type: "string", required: true, description: "Connected remote host id." },
+      sessionId: { type: "string", required: true, description: "Remote session id." },
+      text: { type: "string", required: true, description: "Prompt text." },
+      mode: { type: "string", enum: ["queue", "steer"], description: "Delivery mode (default queue)." }
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: { accepted: { type: "boolean", required: true } }
+      },
+      render: renderJson
+    },
+    async execute(args) {
+      return service.promptSession(args.hostId, args.sessionId, args.text, args.mode);
+    }
+  }));
+  ctx.tools.register(defineTool({
+    name: "remote_session_cancel",
+    description: "Cancel the active turn of a remote DSH session.",
+    parameters: {
+      hostId: { type: "string", required: true, description: "Connected remote host id." },
+      sessionId: { type: "string", required: true, description: "Remote session id." }
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: { accepted: { type: "boolean", required: true } }
+      },
+      render: renderJson
+    },
+    async execute(args) {
+      return service.cancelSession(args.hostId, args.sessionId);
+    }
+  }));
+}
+
+// src/index.ts
+var name = "dsh-remote-local";
+var inject = ["connection", "credentials"];
+async function apply(ctx, config = {}) {
+  const resolved = resolveConfig(config);
+  const service = new RemoteHostsService(ctx, resolved, {
+    resolveModelKey: async () => {
+      try {
+        const resolvedKey = await ctx.credentials.resolve(credentialRef(resolved.modelCredentialRef));
+        return resolvedKey?.value;
+      } catch (error) {
+        ctx.logger.warn("dsh-remote-local: could not resolve %s: %s", resolved.modelCredentialRef, String(error));
+        return void 0;
+      }
+    }
+  });
+  await service.start();
+  const mirrors = new RemoteMirrorService(ctx, service, resolved);
+  await mirrors.start();
+  const terminals = new RemoteTerminals(ctx, service, mirrors);
+  ctx.effect(() => registerTerminalApi(ctx, terminals), "dsh-remote-local: remote terminal route");
+  ctx.inject(["workspaceFiles"], (child) => {
+    installRemoteWorkspaceFiles(child, mirrors, service);
+  });
+  ctx.effect(
+    () => {
+      const dispose = registerHostApi(ctx, service, mirrors);
+      return () => {
+        void dispose();
+      };
+    },
+    "dsh-remote-local: authenticated host API"
+  );
+  installRemoteToolGuards(ctx);
+  ctx.inject(["tools"], (child) => {
+    registerRemoteTools(child, service);
+  });
+  ctx.effect(
+    () => () => {
+      terminals.dispose();
+      void mirrors.dispose();
+      void service.dispose();
+    },
+    "dsh-remote-local: tunnel and mirror lifecycle"
+  );
+  ctx.logger.info(
+    "dsh-remote-local: %d host(s), state in %s",
+    service.list().length,
+    resolved.stateDir
+  );
+}
+export {
+  Config,
+  HOST_API_PATH,
+  RemoteHostsService,
+  apply,
+  inject,
+  name
+};