dsh-over-ssh 0.0.0-stage → 0.1.1

package/lib/local-bridge-refs.js

@@ -0,0 +1,16 @@
+// src/local-bridge-refs.ts
+import "@deepseek-ai/cordis";
+var LocalFileReferencesBridge = class {
+  static inject = ["fileReferences"];
+  constructor(ctx) {
+    const local = ctx.get("fileReferences");
+    if (local === void 0) {
+      ctx.logger?.warn?.("local-bridge-refs: \u9694\u79BB\u57DF\u91CC\u6CA1\u6709 fileReferences\uFF1B\u8DEF\u7531\u5668\u5C06\u6CA1\u6709\u672C\u5730\u540E\u7AEF");
+      return;
+    }
+    ctx.provide("localFileReferences", local);
+  }
+};
+export {
+  LocalFileReferencesBridge as default
+};

package/lib/local-bridge.js

@@ -0,0 +1,16 @@
+// src/local-bridge.ts
+import "@deepseek-ai/cordis";
+var LocalFsBridge = class {
+  static inject = ["fs"];
+  constructor(ctx) {
+    const local = ctx.get("fs");
+    if (local === void 0) {
+      ctx.logger?.warn?.("local-bridge: \u9694\u79BB\u57DF\u91CC\u6CA1\u6709 fs\uFF1B\u8DEF\u7531\u5668\u5C06\u6CA1\u6709\u672C\u5730\u540E\u7AEF");
+      return;
+    }
+    ctx.provide("localFs", local);
+  }
+};
+export {
+  LocalFsBridge as default
+};

package/lib/terminal-wrapper.js

@@ -0,0 +1,299 @@
+#!/usr/bin/env -S node
+
+// tools/over-ssh-terminal.ts
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/host/domain/errors.ts
+var SshDevError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "SshDevError";
+    this.code = code;
+    this.details = details;
+  }
+};
+
+// src/shared/root-keys.ts
+function normalizeLocalPath(path, options = {}) {
+  const caseInsensitive = options.caseInsensitive ?? false;
+  const unified = path.replace(/\\/g, "/");
+  const unc = unified.startsWith("//");
+  const posixAbsolute = unified.startsWith("/");
+  const driveMatch = /^([A-Za-z]):/.exec(unified);
+  const driveLetter = driveMatch?.[1];
+  const drive = driveLetter === void 0 ? "" : `${driveLetter.toUpperCase()}:`;
+  const rest = unc ? unified.slice(2) : drive === "" ? unified : unified.slice(2);
+  const segments = [];
+  for (const segment of rest.split("/")) {
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") {
+      segments.pop();
+      continue;
+    }
+    segments.push(segment);
+  }
+  const body = segments.join("/");
+  let normalized;
+  if (unc) normalized = `//${body}`;
+  else if (drive !== "") normalized = body === "" ? `${drive}/` : `${drive}/${body}`;
+  else if (posixAbsolute) normalized = body === "" ? "/" : `/${body}`;
+  else normalized = body === "" ? "." : body;
+  return caseInsensitive ? normalized.toLowerCase() : normalized;
+}
+
+// src/host/domain/roots/root.ts
+function normalizeLocalPath2(path, options = {}) {
+  return normalizeLocalPath(path, { caseInsensitive: options.caseInsensitive ?? process.platform === "win32" });
+}
+function localPathContains(root, candidate, options = {}) {
+  const normalizedRoot = normalizeLocalPath2(root, options);
+  const normalizedCandidate = normalizeLocalPath2(candidate, options);
+  if (normalizedRoot === "/" || /^[a-z]:\/$/.test(normalizedRoot)) {
+    return normalizedCandidate.startsWith(normalizedRoot);
+  }
+  return normalizedCandidate === normalizedRoot || normalizedCandidate.startsWith(`${normalizedRoot}/`);
+}
+function fnv1aHex(input) {
+  let hash = 2166136261;
+  for (let index = 0; index < input.length; index++) {
+    hash ^= input.charCodeAt(index);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+
+// src/host/domain/shell.ts
+function quote(value) {
+  if (value.includes("\0")) {
+    throw new SshDevError("REMOTE_COMMAND_FAILED", "\u8DEF\u5F84\u6216\u53C2\u6570\u4E2D\u4E0D\u80FD\u5305\u542B NUL \u5B57\u7B26", {});
+  }
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+// src/host/domain/session/terminal-target.ts
+var MANIFEST_VERSION = 1;
+var SESSION_STATE_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+function parseRootManifest(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (parsed === null || typeof parsed !== "object") return void 0;
+  const candidate = parsed;
+  if (candidate.version !== MANIFEST_VERSION) return void 0;
+  if (!Array.isArray(candidate.roots)) return void 0;
+  const roots = [];
+  for (const entry of candidate.roots) {
+    if (entry === null || typeof entry !== "object") continue;
+    const root = entry;
+    if (typeof root.connectionId !== "string" || typeof root.remoteRoot !== "string") continue;
+    if (typeof root.anchorPath !== "string" || root.anchorPath === "") continue;
+    if (root.ssh === void 0 || typeof root.ssh.destination !== "string" || !Array.isArray(root.ssh.args)) continue;
+    roots.push({
+      connectionId: root.connectionId,
+      remoteRoot: root.remoteRoot,
+      anchorPath: root.anchorPath,
+      ssh: { destination: root.ssh.destination, args: [...root.ssh.args] }
+    });
+  }
+  return { version: MANIFEST_VERSION, roots };
+}
+function parseSessionState(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (parsed === null || typeof parsed !== "object") return void 0;
+  const state = parsed;
+  if (typeof state.sessionId !== "string" || state.sessionId === "") return void 0;
+  if (typeof state.connectionId !== "string" || typeof state.remoteRoot !== "string") return void 0;
+  if (typeof state.recordedAt !== "number" || !Number.isFinite(state.recordedAt)) return void 0;
+  if (state.ssh === void 0 || typeof state.ssh.destination !== "string" || !Array.isArray(state.ssh.args)) return void 0;
+  return {
+    sessionId: state.sessionId,
+    connectionId: state.connectionId,
+    remoteRoot: state.remoteRoot,
+    ssh: { destination: state.ssh.destination, args: [...state.ssh.args] },
+    recordedAt: state.recordedAt
+  };
+}
+function remoteCommandFor(remoteRoot, remoteShell = "$SHELL") {
+  return `cd ${quote(remoteRoot)} && exec ${remoteShell} -l`;
+}
+function sshArgvFor(ssh, remoteCommand) {
+  return ["ssh", "-tt", ...ssh.args, ssh.destination, "--", remoteCommand];
+}
+function decideTerminal(options) {
+  const now = options.now ?? Date.now();
+  const local = { kind: "local", argv: [options.localShell], reason: "no-target" };
+  const state = options.sessionState;
+  if (state !== void 0) {
+    if (now - state.recordedAt > SESSION_STATE_MAX_AGE_MS || state.recordedAt > now + 6e4) {
+      const manifestRoot = matchRoot(options.manifest, options.cwd, now);
+      return manifestRoot === void 0 ? { ...local, reason: "state-unusable" } : remoteDecision(manifestRoot, "anchor", options.remoteShell);
+    }
+    const command = remoteCommandFor(state.remoteRoot, options.remoteShell);
+    return {
+      kind: "remote",
+      connectionId: state.connectionId,
+      remoteRoot: state.remoteRoot,
+      argv: sshArgvFor(state.ssh, command),
+      remoteCommand: command,
+      reason: "session"
+    };
+  }
+  const matched = matchRoot(options.manifest, options.cwd, now);
+  if (matched !== void 0) return remoteDecision(matched, "anchor", options.remoteShell);
+  return options.manifest === void 0 ? { ...local, reason: "no-target" } : local;
+}
+function matchRoot(manifest, cwd, _now) {
+  if (manifest === void 0) return void 0;
+  return manifest.roots.find((root) => localPathContains(root.anchorPath, cwd, { caseInsensitive: false }));
+}
+function remoteDecision(root, reason, remoteShell) {
+  const command = remoteCommandFor(root.remoteRoot, remoteShell ?? "$SHELL");
+  return {
+    kind: "remote",
+    connectionId: root.connectionId,
+    remoteRoot: root.remoteRoot,
+    argv: sshArgvFor(root.ssh, command),
+    remoteCommand: command,
+    reason
+  };
+}
+
+// src/host/integration/tools/terminal-manifest.ts
+function sessionFileName(sessionId) {
+  const sanitized = sessionId.replaceAll(/[^A-Za-z0-9._-]/g, "_").slice(0, 48);
+  return `${sanitized}-${fnv1aHex(sessionId)}.json`;
+}
+
+// tools/over-ssh-terminal.ts
+var RECONNECT_DELAYS_MS = [500, 1e3, 2e3, 4e3];
+var SSH_CONNECTION_FAILED = 255;
+function parseWrapperArgs(argv) {
+  const flags = /* @__PURE__ */ new Map();
+  for (let index = 0; index < argv.length; index++) {
+    const token = argv[index];
+    if (token === void 0 || !token.startsWith("--")) continue;
+    const next = argv[index + 1];
+    if (next !== void 0 && !next.startsWith("--")) {
+      flags.set(token.slice(2), next);
+      index++;
+    } else {
+      flags.set(token.slice(2), "true");
+    }
+  }
+  return flags;
+}
+function defaultLocalShell(platform, env) {
+  if (platform === "win32") return env["COMSPEC"] ?? "cmd.exe";
+  return env["SHELL"] ?? "/bin/sh";
+}
+async function readIfPresent(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+async function loadInputs(options) {
+  const manifestRaw = await readIfPresent(join(options.stateDir, "roots.json"));
+  const manifest = manifestRaw === void 0 ? void 0 : parseRootManifest(manifestRaw);
+  if (options.sessionId === void 0) return { manifest, sessionState: void 0 };
+  const stateRaw = await readIfPresent(join(options.stateDir, "state", sessionFileName(options.sessionId)));
+  return { manifest, sessionState: stateRaw === void 0 ? void 0 : parseSessionState(stateRaw) };
+}
+var STATE_DIR_NAMES = ["over-ssh", "remote-workspace", "ssh-dev"];
+function defaultStateDir() {
+  const base = join(homedir(), ".dsh");
+  for (const name of STATE_DIR_NAMES) {
+    const dir = join(base, name);
+    if (existsSync(join(dir, "roots.json"))) return dir;
+  }
+  return join(base, STATE_DIR_NAMES[0]);
+}
+async function decide(input) {
+  const flags = parseWrapperArgs(input.argv);
+  const stateDir = flags.get("state-dir") ?? input.env["DSH_OVER_SSH_STATE_DIR"] ?? input.env["DSH_SSH_DEV_STATE_DIR"] ?? defaultStateDir();
+  const sessionId = flags.get("session") ?? input.env["DSH_SESSION_ID"];
+  const localShell = flags.get("local-shell") ?? defaultLocalShell(input.platform ?? process.platform, input.env);
+  const inputs = await loadInputs({ stateDir, sessionId });
+  const decideOptions = {
+    cwd: input.cwd,
+    localShell,
+    ...inputs.manifest === void 0 ? {} : { manifest: inputs.manifest },
+    ...inputs.sessionState === void 0 ? {} : { sessionState: inputs.sessionState }
+  };
+  const base = decideTerminal(decideOptions);
+  const override = flags.get("remote-command");
+  const decision = override === void 0 || base.kind !== "remote" ? base : { ...base, argv: [...base.argv.slice(0, -1), override], remoteCommand: override };
+  return { decision, label: flags.get("name") ?? "SSH / Local", stateDir, sessionId, localShell };
+}
+async function main(input) {
+  const { decision } = await decide(input);
+  if (parseWrapperArgs(input.argv).has("dry-run")) {
+    process.stdout.write(`${JSON.stringify(decision, void 0, 2)}
+`);
+    return 0;
+  }
+  const [executable, ...args] = decision.argv;
+  if (executable === void 0) throw new Error("terminal wrapper: empty argv");
+  const spawnFn = input.spawnFn ?? spawn;
+  const sleepFn = input.sleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const runOnce = async () => {
+    const child = spawnFn(executable, args, {
+      stdio: "inherit",
+      // A local terminal keeps the caller's cwd; a remote one is entered by the ssh command itself.
+      ...decision.kind === "local" ? { cwd: input.cwd } : {}
+    });
+    return await new Promise((resolve) => {
+      child.on("exit", (code, signal) => {
+        if (typeof code === "number") resolve({ code, signalled: false });
+        else resolve({ code: signal === null || signal === void 0 ? 0 : 1, signalled: true });
+      });
+      child.on("error", () => resolve({ code: 127, signalled: false }));
+    });
+  };
+  const first = await runOnce();
+  if (decision.kind !== "remote" || parseWrapperArgs(input.argv).has("no-reconnect")) return first.code;
+  let outcome = first;
+  for (const delay of RECONNECT_DELAYS_MS) {
+    if (outcome.signalled || outcome.code !== SSH_CONNECTION_FAILED) return outcome.code;
+    process.stderr.write(
+      `\r
+[dsh] \u4E0E\u8FDC\u7AEF\u7684\u8FDE\u63A5\u5DF2\u65AD\u5F00\uFF0C${delay} ms \u540E\u91CD\u8FDE\uFF08\u65B0\u7684\u767B\u5F55 shell\uFF1B\u539F\u5148\u8FD0\u884C\u7684\u8FDB\u7A0B\u5DF2\u4E22\u5931\uFF09\u2026\r
+`
+    );
+    await sleepFn(delay);
+    outcome = await runOnce();
+  }
+  return outcome.code;
+}
+var selfPath = fileURLToPath(import.meta.url);
+if (process.argv[1] !== void 0 && process.argv[1] === selfPath) {
+  main({ argv: process.argv.slice(2), env: process.env, cwd: process.cwd(), platform: process.platform }).then((code) => process.exit(code)).catch((error) => {
+    process.stderr.write(`over-ssh terminal wrapper: ${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(1);
+  });
+}
+export {
+  RECONNECT_DELAYS_MS,
+  decide,
+  defaultLocalShell,
+  loadInputs,
+  main,
+  parseWrapperArgs
+};

package/lib/types/src/client/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The web client half: one settings section that explains how this plugin chooses a transport, the connection
+ * list once the host answers, the editable remote-workspaces editor (`src/client/roots-panel-view.ts`) that
+ * adds and removes roots and connections through the host's same-origin `/api/over-ssh/roots` route,
+ * the **remote-files tab** (`src/client/roots/remote-files-tab.ts`) that the editor opens into the sidebar's
+ * right column,
+ * the **directory-flow occupant** (`src/client/workspace-directory-flow.ts`) that both workspace surfaces
+ * render their "add workspace" action from, and the **session entry**
+ * (`src/client/session-directory.ts`) that adds a directory to the workspace a session is already in,
+ * without creating a workspace.
+ *
+ * Both browsers of the flow and the session entry are the same component
+ * (`src/client/directory-browser.ts`): local levels come from this plugin's own read-only `list-local`
+ * action and remote levels from its `list-remote` action, both through the same same-origin route. The
+ * platform's `uiWorkspace.listDirectory()` is deliberately **not** used: it needs the directory-picker's
+ * `browse` capability, which a profile whose composed picker serves only the native dialog does not have
+ * (see `doc/02-platform/roots-http-route.md` §2).
+ *
+ * Deliberately small, but structurally complete:
+ *
+ *  - dictionaries are registered through the **typed** `ctx.locale.register` (both shipped locales required);
+ *  - the section is registered through `ctx.slots.register` inside `ctx.effect`, so unloading the plugin
+ *    removes it;
+ *  - the directory flow and the session entry go through `ctx.slots.inject` instead, because their holes
+ *    belong to other entries (the workspace surfaces, the composer), which may activate before or after this
+ *    plugin and whose absence must not fail the rest of this half;
+ *  - the panel receives its data through the registration's `inject` face, never through `ctx` (components
+ *    cannot see `ctx` — platform contract);
+ *  - the section re-registers on `locale/change`, because registrant options carry localized text and the
+ *    shell does not subscribe to locale state on the registrant's behalf; the same re-registration is what
+ *    brings the first host rows onto the screen (the slot's inject face is a synchronous snapshot, so new
+ *    data needs a fresh registration until an observable source replaces it);
+ *  - the host channel is mounted here, by this plugin: `api-remotes` only mounts the packages it lists, and a
+ *    third-party half is not one of them. `remote.<namespace>` is therefore **not** in `inject` — waiting for
+ *    a service this plugin creates itself would deadlock activation;
+ *  - the **right sidebar** is an optional seam like `uiWorkspace`: its two services are read through
+ *    `ctx.get`, never awaited, so a profile without that column loses one tab and nothing else.
+ *
+ * @module dsh-over-ssh/client
+ */
+import { Context } from '@deepseek-ai/cordis';
+/** Client services this half needs. `remote` is injected; `remote.sshdev` is mounted by `apply` below. */
+export declare const inject: string[];
+/**
+ * Install the client half.
+ *
+ * @param ctx - client plugin context (has `slots`, `locale` and `remote` by injection).
+ */
+export declare function apply(ctx: Context): void;