pi-ssh-remote 0.1.6 → 0.1.7

package/CHANGELOG.md

@@ -18,6 +18,21 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). Rel
 
 - None.
 
+## [0.1.7] - 2026-08-05
+
+### Added
+
+- Added non-secret, session-scoped SSH workspace state for endpoint, remote directory, tool-routing mode, and port forwards.
+
+### Changed
+
+- `/new` now inherits the active SSH workspace, forks and clones retain their source workspace, and `/resume` restores the selected historical session's recorded workspace.
+- Session changes close the previous transport cleanly and reconnect the target workspace without storing passwords or other credentials in session files.
+
+### Fixed
+
+- None.
+
 ## [0.1.6] - 2026-08-05
 
 ### Added
@@ -130,7 +145,8 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). Rel
 
 - None.
 
-[Unreleased]: https://github.com/petrichor20211/pi-ssh-remote/compare/v0.1.6...HEAD
+[Unreleased]: https://github.com/petrichor20211/pi-ssh-remote/compare/v0.1.7...HEAD
+[0.1.7]: https://github.com/petrichor20211/pi-ssh-remote/compare/v0.1.6...v0.1.7
 [0.1.6]: https://github.com/petrichor20211/pi-ssh-remote/compare/v0.1.5...v0.1.6
 [0.1.5]: https://github.com/petrichor20211/pi-ssh-remote/compare/v0.1.4...v0.1.5
 [0.1.4]: https://github.com/petrichor20211/pi-ssh-remote/releases/tag/v0.1.4

package/README.md

@@ -35,7 +35,7 @@ Each `user@host:port` endpoint remembers its remote working directory, note, ser
 
 ### Resilient and bounded by default
 
-Dropped connections are automatically re-established during the active session. Remote commands have a 30-second default timeout. Remote text reads fetch focused ranges instead of downloading complete files, command output is streamed through bounded buffers, and a 32 KB per-turn budget prevents parallel tools from flooding model context. Complete oversized command output is preserved in a permission-restricted temporary file.
+Dropped connections are automatically re-established during the active session. SSH workspace state is also session-aware: `/new` inherits the current workspace, forks and clones retain their source workspace, and `/resume` restores the selected session's recorded endpoint, remote directory, routing mode, and forwards. Remote commands have a 30-second default timeout. Remote text reads fetch focused ranges instead of downloading complete files, command output is streamed through bounded buffers, and a 32 KB per-turn budget prevents parallel tools from flooding model context. Complete oversized command output is preserved in a permission-restricted temporary file.
 
 ### Hybrid local/remote workflows
 
@@ -195,7 +195,7 @@ Endpoint configuration is stored locally in:
 ~/.pi/agent/ssh-remote-config.json
 ```
 
-Saved values include endpoints, active endpoint, notes, server-specific memories, remote working directories, forwards, preview settings, and model-output budgets. Server memory is user-configured trusted context and is inserted into each model request only while that endpoint is the active remote workspace; it is not read from the remote server. Passwords are **never written to this file**: SSH agent authentication is preferred, and prompted passwords remain only in process memory.
+Saved global values include endpoints, active endpoint, notes, server-specific memories, remote working directories, forwards, preview settings, and model-output budgets. Each Pi session also stores non-secret SSH workspace metadata so `/resume` can restore the server associated with that session. Server memory is user-configured trusted context and is inserted into each model request only while that endpoint is the active remote workspace; it is not read from the remote server. Passwords are **never written to this file**: SSH agent authentication is preferred, and prompted passwords remain only in process memory.
 
 New or changed host keys require interactive confirmation and are stored separately from OpenSSH. By default, remote text reads return at most 400 lines or 16 KB, remote command results return the last 200 lines or 8 KB, and all remote tools in one agent turn share a 32 KB output budget. Text reads support `offset`/`limit` continuation without downloading the complete remote file. Oversized command output is streamed to a permission-restricted temporary local file rather than accumulated in memory. Configured limits may be raised only to the extension's hard safety ceilings. Preview-line settings affect only the collapsed UI and never increase model output.
 
@@ -205,13 +205,13 @@ The extension currently supports direct SSH commands with `-p` and `-l`. It does
 
 ## Releases
 
-Latest release: [v0.1.6](https://github.com/petrichor20211/pi-ssh-remote/releases/tag/v0.1.6)
+Latest release: [v0.1.7](https://github.com/petrichor20211/pi-ssh-remote/releases/tag/v0.1.7)
 
 | Version | Date | Highlights |
 |---|---|---|
+| [0.1.7](CHANGELOG.md#017---2026-08-05) | 2026-08-05 | Session-aware SSH workspace restoration for new, forked, and resumed sessions |
 | [0.1.6](CHANGELOG.md#016---2026-08-05) | 2026-08-05 | Bounded remote reads, streamed command output, and per-turn output budgets |
 | [0.1.5](CHANGELOG.md#015---2026-08-04) | 2026-08-04 | Endpoint-specific server memory and automatic context injection |
-| [0.1.4](CHANGELOG.md#014---2026-07-31) | 2026-07-31 | Endpoint notes and enforced remote command timeouts |
 
 See [CHANGELOG.md](CHANGELOG.md) for the complete release history, including additions, behavior changes, and bug fixes.
 

package/README.zh-CN.md

@@ -58,7 +58,7 @@ SSH remote H100 训练机 (root@gpu-box.example.com:2202):/srv/project
 
 ### 断线后可以自动恢复
 
-当前会话中如果 SSH 连接意外断开，插件会尝试自动重连，不需要 Agent 从头建立工作环境。
+当前会话中如果 SSH 连接意外断开，插件会尝试自动重连，不需要 Agent 从头建立工作环境。SSH 工作区状态也会跟随 Pi session：`/new` 继承当前工作区，`/fork` 和 `/clone` 保留来源工作区，`/resume` 恢复目标历史 session 记录的服务器、远程目录、路由模式和端口转发。
 
 ### 对 Agent 上下文更友好
 
@@ -249,7 +249,7 @@ Pi 会通过插件提供的 `ssh_remote_control` 工具完成这些操作。
 ~/.pi/agent/ssh-remote-config.json
 ```
 
-其中包括：
+全局配置包括：
 
 - 已保存的服务器；
 - 当前选中的服务器；
@@ -260,7 +260,7 @@ Pi 会通过插件提供的 `ssh_remote_control` 工具完成这些操作。
 - 命令预览设置；
 - 模型输出预算。
 
-服务器记忆是由用户在本地配置的可信上下文，不会从远程服务器自动读取；仅当对应 endpoint 作为远端工作区启用时才会加入每次模型请求。
+此外，每个 Pi session 都会记录不含凭据的 SSH 工作区元数据，用于在 `/resume` 时恢复该历史 session 对应的服务器环境。服务器记忆是由用户在本地配置的可信上下文，不会从远程服务器自动读取；仅当对应 endpoint 作为远端工作区启用时才会加入每次模型请求。
 
 密码不会写入配置文件。插件会优先使用 SSH agent；如果需要手动输入密码，密码只会缓存在当前 Pi 进程的内存中。
 
@@ -283,13 +283,13 @@ Pi 会通过插件提供的 `ssh_remote_control` 工具完成这些操作。
 
 ## 版本发布
 
-最新版本：[v0.1.6](https://github.com/petrichor20211/pi-ssh-remote/releases/tag/v0.1.6)
+最新版本：[v0.1.7](https://github.com/petrichor20211/pi-ssh-remote/releases/tag/v0.1.7)
 
 | 版本 | 日期 | 主要内容 |
 |---|---|---|
+| [0.1.7](CHANGELOG.md#017---2026-08-05) | 2026-08-05 | 新建、分叉和恢复 session 时自动恢复对应 SSH 工作区 |
 | [0.1.6](CHANGELOG.md#016---2026-08-05) | 2026-08-05 | 有界远端读取、流式命令输出与每轮输出预算 |
 | [0.1.5](CHANGELOG.md#015---2026-08-04) | 2026-08-04 | endpoint 级服务器记忆与自动上下文注入 |
-| [0.1.4](CHANGELOG.md#014---2026-07-31) | 2026-07-31 | endpoint 备注与远程命令强制超时 |
 
 完整的新增内容、行为变更和 Bug 修复记录请查看 [CHANGELOG.md](CHANGELOG.md)。
 

package/index.ts

@@ -48,7 +48,7 @@ interface RemoteState extends ParsedSsh {
 
 interface CredentialCache {
   passwords: Map<string, string>;
-  resume?: { command: string; cwd: string };
+  resume?: { command: string; cwd: string; routeRemoteTools: boolean; forwards?: string[] };
 }
 
 interface RemoteEndpointConfig {
@@ -80,6 +80,15 @@ interface ForwardSpec {
   remotePort: number;
 }
 
+interface SessionRemoteState {
+  version: 1;
+  connected: boolean;
+  command?: string;
+  cwd?: string;
+  routeRemoteTools?: boolean;
+  forwards?: string[];
+}
+
 const AGENT_DIR = join(process.env.HOME || ".", CONFIG_DIR_NAME, "agent");
 const KNOWN_HOSTS_FILE = join(AGENT_DIR, "ssh-remote-known-hosts.json");
 const REMOTE_CONFIG_FILE = join(AGENT_DIR, "ssh-remote-config.json");
@@ -95,6 +104,7 @@ const MIN_MODEL_OUTPUT_BYTES = 1024;
 const OUTPUT_FOOTER_RESERVE_BYTES = 512;
 const DEFAULT_REMOTE_TIMEOUT_SECONDS = 30;
 const MAX_REMOTE_TIMEOUT_SECONDS = 2_147_483_647 / 1000;
+const SESSION_STATE_ENTRY_TYPE = "pi-ssh-remote-state";
 const CACHE_KEY = "__piHpcCredentialCacheV1";
 const cacheHost = globalThis as typeof globalThis & { [CACHE_KEY]?: CredentialCache };
 const credentialCache = cacheHost[CACHE_KEY] ??= { passwords: new Map<string, string>() };
@@ -659,6 +669,9 @@ export default function sshRemoteExtension(pi: ExtensionAPI) {
   let currentCtx: any;
   let reconnectPromise: Promise<RemoteState> | null = null;
   const forwardServers = new Map<number, Server>();
+  const forwardSpecs = new Map<number, ForwardSpec>();
+  let sessionReady = false;
+  let restoringSessionState = false;
   let lastConnectionError: string | undefined;
   let lastCommand = credentialCache.resume?.command ?? activeSshCommand() ?? "";
   let turnOutputBytes = 0;
@@ -684,6 +697,42 @@ export default function sshRemoteExtension(pi: ExtensionAPI) {
     return posix.join(remote.cwd, normalized);
   };
 
+  const serializeForward = (spec: ForwardSpec): string => `${spec.localPort}:${spec.remoteHost}:${spec.remotePort}`;
+
+  const currentSessionRemoteState = (): SessionRemoteState => remote ? {
+    version: 1,
+    connected: true,
+    command: remote.command,
+    cwd: remote.cwd,
+    routeRemoteTools,
+    forwards: [...forwardSpecs.values()].map(serializeForward),
+  } : { version: 1, connected: false };
+
+  const persistSessionRemoteState = (): void => {
+    if (!sessionReady || restoringSessionState) return;
+    pi.appendEntry(SESSION_STATE_ENTRY_TYPE, currentSessionRemoteState());
+  };
+
+  const loadSessionRemoteState = (ctx: any): SessionRemoteState | undefined => {
+    const branch = ctx.sessionManager.getBranch();
+    for (let index = branch.length - 1; index >= 0; index--) {
+      const entry = branch[index] as any;
+      if (entry.type !== "custom" || entry.customType !== SESSION_STATE_ENTRY_TYPE) continue;
+      const data = entry.data as Partial<SessionRemoteState> | undefined;
+      if (!data || data.version !== 1 || typeof data.connected !== "boolean") return undefined;
+      if (data.connected && (typeof data.command !== "string" || typeof data.cwd !== "string")) return undefined;
+      return {
+        version: 1,
+        connected: data.connected,
+        ...(data.command ? { command: data.command } : {}),
+        ...(data.cwd ? { cwd: data.cwd } : {}),
+        ...(typeof data.routeRemoteTools === "boolean" ? { routeRemoteTools: data.routeRemoteTools } : {}),
+        ...(Array.isArray(data.forwards) ? { forwards: data.forwards.filter((value): value is string => typeof value === "string") } : {}),
+      };
+    }
+    return undefined;
+  };
+
   const limitRemoteToolResult = (result: any, kind: "read" | "exec", startLine = 1, requestedMaxLines?: number) => {
     const limits = configuredOutputLimits();
     const configuredMaxBytes = kind === "read" ? limits.readMaxBytes : limits.execMaxBytes;
@@ -772,6 +821,7 @@ export default function sshRemoteExtension(pi: ExtensionAPI) {
 
   async function reconnectRemote(): Promise<RemoteState> {
     if (reconnectPromise) return reconnectPromise;
+    const resumeRouting = remote ? routeRemoteTools : (credentialCache.resume?.routeRemoteTools ?? true);
     const source = remote ?? (credentialCache.resume ? { ...parseSshCommand(credentialCache.resume.command), cwd: credentialCache.resume.cwd } : null);
     if (!source) throw new Error("No SSH remote connection is available to reconnect");
     const parsed = parseSshCommand(source.command);
@@ -780,7 +830,8 @@ export default function sshRemoteExtension(pi: ExtensionAPI) {
       const oldClient = remote?.client;
       const next = await establish(parsed, password, source.cwd);
       remote = next;
-      credentialCache.resume = { command: parsed.command, cwd: next.cwd };
+      routeRemoteTools = resumeRouting;
+      credentialCache.resume = { command: parsed.command, cwd: next.cwd, routeRemoteTools, forwards: credentialCache.resume?.forwards };
       oldClient?.end();
       if (currentCtx) {
         status(currentCtx);
@@ -810,9 +861,10 @@ export default function sshRemoteExtension(pi: ExtensionAPI) {
       `cd -- ${quote(remote!.cwd)} && ${targetCommand} && pwd -P`,
     ))).toString().trim();
     remote.cwd = resolved;
-    credentialCache.resume = { command: remote.command, cwd: resolved };
+    credentialCache.resume = { command: remote.command, cwd: resolved, routeRemoteTools, forwards: [...forwardSpecs.values()].map(serializeForward) };
     saveEndpointConfig(remote.command, { remoteCwd: resolved }, true);
     status(ctx);
+    persistSessionRemoteState();
     return resolved;
   };
 
@@ -874,11 +926,12 @@ export default function sshRemoteExtension(pi: ExtensionAPI) {
       routeRemoteTools = true;
       previous?.end();
       if (password) setCachedPassword(parsed, password);
-      credentialCache.resume = { command, cwd: next.cwd };
+      credentialCache.resume = { command, cwd: next.cwd, routeRemoteTools, forwards: [] };
       lastCommand = command;
       lastConnectionError = undefined;
       saveEndpointConfig(command, { remoteCwd: next.cwd }, true);
       status(ctx);
+      persistSessionRemoteState();
       ctx.ui.notify(`SSH remote connected: ${endpointDisplayLabel(next)}:${next.cwd}`, "info");
       return next;
     } catch (error) {
@@ -922,14 +975,32 @@ export default function sshRemoteExtension(pi: ExtensionAPI) {
       });
     });
     forwardServers.set(spec.localPort, server);
+    forwardSpecs.set(spec.localPort, spec);
   };
 
   const stopForwards = async (): Promise<void> => {
     const servers = [...forwardServers.values()];
     forwardServers.clear();
+    forwardSpecs.clear();
     await Promise.all(servers.map((server) => new Promise<void>((resolve) => server.close(() => resolve()))));
   };
 
+  const restoreSessionRemoteState = async (saved: SessionRemoteState, ctx: any): Promise<void> => {
+    if (!saved.connected) {
+      credentialCache.resume = undefined;
+      status(ctx);
+      return;
+    }
+    const command = saved.command!;
+    const next = await connectInteractive(command, ctx, saved.cwd);
+    if (!next) throw new Error(lastConnectionError || "SSH remote session restore was cancelled or failed");
+    routeRemoteTools = saved.routeRemoteTools ?? true;
+    const specs = (saved.forwards ?? []).map(parseForwardSpec);
+    for (const spec of specs) await startForward(spec);
+    credentialCache.resume = { command, cwd: next.cwd, routeRemoteTools, forwards: [...forwardSpecs.values()].map(serializeForward) };
+    status(ctx);
+  };
+
   const disconnect = (ctx: any, forgetPassword = false) => {
     const previous = remote;
     remote = null;
@@ -948,6 +1019,7 @@ export default function sshRemoteExtension(pi: ExtensionAPI) {
     }
     previous?.client.end();
     status(ctx);
+    persistSessionRemoteState();
     ctx.ui.notify(forgetPassword ? "SSH remote disconnected and cached password cleared" : "SSH remote mode disabled (password remains cached in memory only)", "info");
   };
 
@@ -1104,6 +1176,7 @@ export default function sshRemoteExtension(pi: ExtensionAPI) {
       }
       if (params.action === "unforward") {
         await stopForwards();
+        persistSessionRemoteState();
         return { content: [{ type: "text", text: "Closed all extension-managed SSH port forwards." }], details: { forwardedPorts: [] } };
       }
       if (params.action === "forward") {
@@ -1113,7 +1186,9 @@ export default function sshRemoteExtension(pi: ExtensionAPI) {
         const specs = values.map(parseForwardSpec);
         for (const spec of specs) await startForward(spec);
         routeRemoteTools = false;
+        credentialCache.resume = { command: state.command, cwd: state.cwd, routeRemoteTools, forwards: [...forwardSpecs.values()].map(serializeForward) };
         if (currentCtx) status(currentCtx);
+        persistSessionRemoteState();
         const ports = specs.map((spec) => spec.localPort);
         return { content: [{ type: "text", text: `Forwarded local ports: ${ports.join(", ")}; tools remain local.` }], details: { toolRouting: "local", forwardedPorts: ports } };
       }
@@ -1231,6 +1306,7 @@ export default function sshRemoteExtension(pi: ExtensionAPI) {
           previous.client.end();
           await stopForwards();
           status(ctx);
+          persistSessionRemoteState();
         }
         saveRemoteConfig({ ...config, activeEndpoint: key });
         lastCommand = command;
@@ -1309,13 +1385,16 @@ export default function sshRemoteExtension(pi: ExtensionAPI) {
           const specs = values.map(parseForwardSpec);
           for (const spec of specs) await startForward(spec);
           routeRemoteTools = false;
+          credentialCache.resume = { command: state.command, cwd: state.cwd, routeRemoteTools, forwards: [...forwardSpecs.values()].map(serializeForward) };
           status(ctx);
+          persistSessionRemoteState();
           ctx.ui.notify(`SSH remote port forwarding started; tools remain local in ${localCwd}: ${specs.map((spec) => `127.0.0.1:${spec.localPort}`).join(", ")}`, "info");
         } catch (error) { ctx.ui.notify(`SSH remote port forwarding failed: ${(error as Error).message}`, "error"); }
         return;
       }
       if (action === "unforward") {
         await stopForwards();
+        persistSessionRemoteState();
         ctx.ui.notify("Closed all extension-managed SSH remote port forwards", "info");
         return;
       }
@@ -1378,19 +1457,50 @@ export default function sshRemoteExtension(pi: ExtensionAPI) {
   pi.on("turn_start", () => { turnOutputBytes = 0; });
   pi.on("session_start", async (event, ctx) => {
     currentCtx = ctx;
+    sessionReady = true;
     status(ctx);
-    if (event.reason === "reload" && credentialCache.resume) {
-      try { await reconnectRemote(); }
-      catch (error) { ctx.ui.notify(`SSH remote automatic login after reload failed: ${(error as Error).message}`, "error"); }
+    const saved = loadSessionRemoteState(ctx);
+    const canInheritCurrent = event.reason === "reload" || event.reason === "new" || event.reason === "fork";
+    const inherited = !saved && canInheritCurrent && credentialCache.resume ? credentialCache.resume : undefined;
+    const target: SessionRemoteState | undefined = saved ?? (inherited ? {
+      version: 1,
+      connected: true,
+      command: inherited.command,
+      cwd: inherited.cwd,
+      routeRemoteTools: inherited.routeRemoteTools,
+      forwards: inherited.forwards ?? [],
+    } : undefined);
+    if (!target) {
+      credentialCache.resume = undefined;
+      return;
     }
+    restoringSessionState = true;
+    try {
+      await restoreSessionRemoteState(target, ctx);
+    } catch (error) {
+      ctx.ui.notify(`SSH remote session restore failed: ${(error as Error).message}`, "error");
+    } finally {
+      restoringSessionState = false;
+    }
+    if (inherited && remote) persistSessionRemoteState();
   });
-  pi.on("session_shutdown", (event) => {
+  pi.on("session_shutdown", async (event) => {
+    sessionReady = false;
     const previous = remote;
+    const preserveConnection = event.reason === "reload" || event.reason === "new" || event.reason === "fork";
+    if (previous && preserveConnection) {
+      credentialCache.resume = {
+        command: previous.command,
+        cwd: previous.cwd,
+        routeRemoteTools,
+        forwards: [...forwardSpecs.values()].map(serializeForward),
+      };
+    }
     remote = null;
     routeRemoteTools = false;
-    void stopForwards();
+    await stopForwards();
     previous?.client.end();
-    if (event.reason !== "reload") credentialCache.resume = undefined;
+    if (!preserveConnection) credentialCache.resume = undefined;
   });
   pi.on("user_bash", async (event, ctx) => {
     if (!remote || !routeRemoteTools) return undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ssh-remote",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Persistent remote SSH workspaces for Pi.",
   "type": "module",
   "author": "Yutong Bian",