@hyperdrive.bot/paseo-server 0.3.38 → 0.3.40

package/dist/server/server/agent/providers/claude/transport/pty.js

@@ -49,6 +49,25 @@ function getNodePty() {
 export function __setNodePtyForTesting(stub) {
     nodePty = stub;
 }
+/**
+ * Thrown when something tries to write to a pty whose process has already exited.
+ *
+ * This has a dedicated type because the two failure modes read identically at the call site
+ * and must not: "never spawned" is a programming error, while "already exited" is a normal
+ * runtime event that the layer above has to react to by failing the turn. Before this class
+ * existed, `doWrite` happily called `_pty.write()` on a dead pty, node-pty swallowed it, and
+ * `waitForEcho()`'s fixed timer reported success - so paseo typed prompts into a corpse for
+ * fourteen retries and then told the user "the session itself is still running".
+ */
+export class PtyExitedError extends Error {
+    constructor(op, exitCode = null, exitSignal = null) {
+        super(`PtyTransport.${op} called after the pty process exited`);
+        this.code = "PTY_EXITED";
+        this.name = "PtyExitedError";
+        this.exitCode = exitCode;
+        this.exitSignal = exitSignal;
+    }
+}
 export class PtyTransport {
     constructor() {
         this._pty = null;
@@ -57,12 +76,28 @@ export class PtyTransport {
         this._rows = DEFAULT_ROWS;
         this._killed = false;
         this._exited = false;
+        this._exitInfo = null;
+        this.exitHandlers = [];
         this.injectChain = Promise.resolve();
         this.hookHandlers = [];
         this.hookBuffer = [];
         this.bridgeClose = null;
         this.systemPromptFilePath = null;
     }
+    /**
+     * Has the child process exited?
+     *
+     * Public because guarding the write paths fixes the symptom but leaves the question
+     * unanswerable: `_exited` was private, so no caller could ask a transport whether its
+     * child was alive without provoking an error. `AgentTransport` now declares it.
+     */
+    get exited() {
+        return this._exited;
+    }
+    /** Exit status once the child is gone, else null. */
+    get exitInfo() {
+        return this._exitInfo ? { ...this._exitInfo } : null;
+    }
     /**
      * Bridge-side / test entry point — push a hook event into this transport's
      * stream. If no `onHookEvent` handler is registered yet, the event is
@@ -114,8 +149,24 @@ export class PtyTransport {
             cwd: opts.cwd,
             env: opts.env,
         });
-        this._pty.onExit(() => {
+        // ONE internal subscription owns exit state and fans it out to every public onExit()
+        // handler. Registering handlers straight onto node-pty (the previous shape) meant a
+        // subscriber that attached AFTER the child had already died heard nothing at all -- and
+        // a PtyQuery attaches to a long-lived terminal, not only to a fresh boot, so that is a
+        // reachable case and not a theoretical one.
+        this._pty.onExit(({ exitCode, signal }) => {
+            const code = typeof exitCode === "number" ? exitCode : null;
+            const sig = signal ?? null;
             this._exited = true;
+            this._exitInfo = { code, signal: sig };
+            for (const h of this.exitHandlers) {
+                try {
+                    h(code, sig);
+                }
+                catch {
+                    // one bad subscriber must not stop the others hearing about the death
+                }
+            }
         });
     }
     write(text) {
@@ -138,6 +189,9 @@ export class PtyTransport {
         if (!this._pty) {
             throw new Error("PtyTransport.writeRaw called before spawn()");
         }
+        if (this._exited) {
+            throw new PtyExitedError("writeRaw", this._exitInfo?.code ?? null, this._exitInfo?.signal ?? null);
+        }
         this._pty.write(data);
         await this.waitForEcho();
     }
@@ -148,6 +202,9 @@ export class PtyTransport {
         if (!this._pty) {
             throw new Error("PtyTransport.write called before spawn()");
         }
+        if (this._exited) {
+            throw new PtyExitedError("write", this._exitInfo?.code ?? null, this._exitInfo?.signal ?? null);
+        }
         this._pty.write(this.bracketedPaste(text));
         await this.waitForEcho();
     }
@@ -216,10 +273,17 @@ export class PtyTransport {
         if (!this._pty) {
             throw new Error("PtyTransport.onExit called before spawn()");
         }
-        const disposable = this._pty.onExit(({ exitCode, signal }) => {
-            handler(typeof exitCode === "number" ? exitCode : null, signal ?? null);
-        });
-        return () => disposable.dispose();
+        this.exitHandlers.push(handler);
+        // Already dead: fire, rather than never. Deferred a microtask so a subscriber that
+        // registers from a constructor (PtyQuery does) cannot be re-entered before it has
+        // finished building itself.
+        if (this._exited) {
+            const info = this._exitInfo;
+            queueMicrotask(() => handler(info?.code ?? null, info?.signal ?? null));
+        }
+        return () => {
+            this.exitHandlers = this.exitHandlers.filter((h) => h !== handler);
+        };
     }
     context() {
         if (!this._pty) {

package/dist/server/server/agent/providers/claude/transport/sdk.d.ts

@@ -53,6 +53,8 @@ export declare class SdkTransport implements AgentTransport {
     createQuery(input: ClaudeQueryInput): Query;
     spawn(opts: AgentTransportSpawnOptions): Promise<void>;
     write(text: string): Promise<void>;
+    /** True once the SDK query has been closed/returned. Mirrors PtyTransport.exited. */
+    get exited(): boolean;
     kill(timeoutMs?: number): Promise<void>;
     onHookEvent(_handler: (event: HookEvent) => void): () => void;
     onData(_handler: (chunk: string) => void): () => void;

package/dist/server/server/agent/providers/claude/transport/sdk.js

@@ -135,6 +135,10 @@ export class SdkTransport {
         const queryWithInput = this._query;
         await queryWithInput.input?.send(message);
     }
+    /** True once the SDK query has been closed/returned. Mirrors PtyTransport.exited. */
+    get exited() {
+        return this._exited;
+    }
     async kill(timeoutMs = 5000) {
         if (this._killed)
             return;

package/dist/server/server/agent/providers/claude/transport/types.d.ts

@@ -29,6 +29,14 @@ export type AgentTransportContext = {
     cwd: string;
 };
 export interface AgentTransport {
+    /**
+     * True once the underlying agent process has exited.
+     *
+     * Optional so a transport that genuinely cannot know stays honest by omitting it;
+     * `undefined` means "no liveness signal" and must not be read as "alive". Both shipped
+     * transports implement it.
+     */
+    readonly exited?: boolean;
     spawn(opts: AgentTransportSpawnOptions): Promise<void>;
     write(text: string): Promise<void>;
     /**

package/dist/server/server/session/workspace-provisioning/workspace-provisioning-service.d.ts

@@ -19,9 +19,21 @@ export interface ResolveOrCreateWorkspaceIdInput {
     cwd: string;
     initialTitle: string | null;
 }
+/**
+ * `createdWorkspace` is true ONLY when this call minted a brand new workspace
+ * record. Callers use it to decide whether post-create side effects that are
+ * only correct on a fresh workspace may run — notably workspace auto-naming,
+ * which would otherwise rename a workspace the user already had. Deriving that
+ * from the REQUEST (`!msg.workspaceId`) is wrong now that an omitted id can
+ * resolve to an existing workspace.
+ */
+export interface ResolveOrCreateWorkspaceIdResult {
+    workspaceId: string;
+    createdWorkspace: boolean;
+}
 export interface WorkspaceProvisioningService {
     findOrCreateWorkspaceForDirectory(cwd: string): Promise<PersistedWorkspaceRecord>;
-    resolveOrCreateWorkspaceIdForCreateAgent(input: ResolveOrCreateWorkspaceIdInput): Promise<string>;
+    resolveOrCreateWorkspaceIdForCreateAgent(input: ResolveOrCreateWorkspaceIdInput): Promise<ResolveOrCreateWorkspaceIdResult>;
     createWorkspaceForDirectory(cwd: string, title?: string | null): Promise<PersistedWorkspaceRecord>;
     findOrCreateProjectForDirectory(cwd: string): Promise<PersistedProjectRecord>;
     ensureWorkspaceRecordUnarchived(workspace: PersistedWorkspaceRecord): Promise<PersistedWorkspaceRecord>;

package/dist/server/server/session/workspace-provisioning/workspace-provisioning-service.js

@@ -119,12 +119,36 @@ export function createWorkspaceProvisioningService(deps) {
     }
     async function resolveOrCreateWorkspaceIdForCreateAgent(input) {
         if (input.createdWorktree) {
-            return input.createdWorktree.workspace.workspaceId;
+            return {
+                workspaceId: input.createdWorktree.workspace.workspaceId,
+                createdWorkspace: false,
+            };
         }
         if (input.requestedWorkspaceId) {
-            return input.requestedWorkspaceId;
+            return { workspaceId: input.requestedWorkspaceId, createdWorkspace: false };
         }
-        return (await createWorkspaceForDirectory(input.cwd, input.initialTitle)).workspaceId;
+        // Look before you mint. This branch used to call createWorkspaceForDirectory
+        // unconditionally, so every createAgent that omitted `workspaceId` produced a
+        // SECOND workspace for a directory that already had one — no lookup, not even
+        // against the identical cwd. On one daemon that turned 19 directories into 114
+        // workspace records, 48 of them on a single repo root, and the agent surfaced
+        // in the fresh workspace instead of the one on screen.
+        //
+        // 0.3.38 fixed the palette by making its caller pass the id. That closes one
+        // door and leaves the hole: any other caller (MCP create_agent, loops,
+        // schedules, whatever is written next) still mints. Fix it where ownership is
+        // actually decided.
+        const existing = await findExactWorkspaceByDirectory(input.cwd, { refreshGit: false });
+        if (existing) {
+            const reused = await reclassifyOrUnarchiveWorkspaceForDirectory({
+                workspace: existing,
+                project: await projectRegistry.get(existing.projectId),
+                cwd: await resolveWorkspaceDirectory(input.cwd, { refreshGit: false }),
+            });
+            return { workspaceId: reused.workspaceId, createdWorkspace: false };
+        }
+        const created = await createWorkspaceForDirectory(input.cwd, input.initialTitle);
+        return { workspaceId: created.workspaceId, createdWorkspace: true };
     }
     async function createWorkspaceForDirectory(cwd, title) {
         const checkout = await workspaceGitService.getCheckout(cwd);

package/dist/server/server/session.js

@@ -2693,13 +2693,17 @@ export class Session {
             let createAgentConfig = createdWorktree
                 ? { ...config, cwd: createdWorktree.worktree.worktreePath }
                 : config;
-            const workspaceId = await this.workspaceProvisioning.resolveOrCreateWorkspaceIdForCreateAgent({
+            const { workspaceId, createdWorkspace } = await this.workspaceProvisioning.resolveOrCreateWorkspaceIdForCreateAgent({
                 createdWorktree,
                 requestedWorkspaceId: msg.workspaceId,
                 cwd: createAgentConfig.cwd,
                 initialTitle: workspacePromptTitle,
             });
-            const createdDirectoryWorkspaceForAgent = !createdWorktree && !msg.workspaceId;
+            // Gate auto-naming on what actually happened, NOT on what was requested.
+            // An omitted workspaceId no longer implies a fresh workspace: provisioning
+            // now reuses the one that already owns this cwd, and auto-naming a reused
+            // workspace would rename one the user already had.
+            const createdDirectoryWorkspaceForAgent = !createdWorktree && createdWorkspace;
             // Resuming a past session: the recorded cwd may no longer exist on this
             // machine (different $HOME, deleted folder). The transcript is read from
             // ~/.claude/projects regardless, so fall back to an existing directory