@code-yeongyu/senpi 2026.9.26 → 2026.9.27-3

package/dist/main.js

@@ -5,6 +5,7 @@
  * This file handles CLI argument parsing and translates them into
  * createAgentSession() options. The SDK does the heavy lifting.
  */
+import { existsSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { modelsAreEqual } from "@earendil-works/pi-ai";
@@ -13,7 +14,9 @@ import chalk from "chalk";
 import { normalizeSessionName, parseArgs, printHelp, resolveSessionRuntime } from "./cli/args.js";
 import { checkProviderAuth, createAuthCheckModelRuntime, getProviderCredential, } from "./cli/auth-check.js";
 import { AuthCommandError, getAuthCommandName, getAuthCommandUsage, isAuthCommandHelp, parseAuthCommand, printAuthCommandHelp, validateAuthCommandArgs, } from "./cli/auth-command.js";
+import { movedSessionToContinue } from "./cli/continue-moved.js";
 import { resolveCredentialForPrint } from "./cli/credential-print.js";
+import { chooseCrossProjectAction, confirmSameRepositoryRebind } from "./cli/cross-project-session.js";
 import { dispatchAppServerCommand, dispatchConfigCommand, dispatchHostCommand, dispatchPackageCommand, } from "./cli/deferred-commands.js";
 import { processFileArguments } from "./cli/file-processor.js";
 import { resolveHelpExtensionFlags } from "./cli/help-extension-flags.js";
@@ -35,10 +38,14 @@ import { exportFromFile } from "./core/export-html/index.js";
 import { applyHttpProxySettings, configureHttpDispatcher } from "./core/http-dispatcher.js";
 import { getModelNarrowingPatterns, resolveCliModel, resolveModelScope, } from "./core/model-resolver.js";
 import { ModelRuntime } from "./core/model-runtime.js";
+import { markMovedSessions, withMovedSessions } from "./core/moved-sessions.js";
 import { restoreStdout, takeOverStdout } from "./core/output-guard.js";
+import { recordProcessLifetime } from "./core/process-crash-record.js";
 import { resolveProjectTrusted } from "./core/project-trust.js";
+import { resolveResumeTarget } from "./core/resume-target.js";
 import { formatMissingSessionCwdPrompt, getMissingSessionCwdIssue, MissingSessionCwdError, } from "./core/session-cwd.js";
 import { assertValidSessionId, SessionManager } from "./core/session-manager.js";
+import { classifySessionRepository, readSessionCwd, rebindSessionFile } from "./core/session-rebind.js";
 import { collectSettingsDiagnosticsWithContext } from "./core/settings-diagnostics.js";
 import { SettingsManager } from "./core/settings-manager.js";
 import { shouldJoinSharedHost } from "./core/shared-host-policy.js";
@@ -270,17 +277,25 @@ async function resolveSessionPath(sessionArg, cwd, sessionDir) {
  * Resolves false on stdin EOF (Ctrl+D, closed pipe): without the close handler a
  * readline question never settles once the input stream ends, hanging the process.
  */
-async function promptConfirm(message) {
+export async function promptConfirm(message) {
     return new Promise((resolve) => {
         const rl = createInterface({
             input: process.stdin,
             output: process.stdout,
         });
+        let settled = false;
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(result);
+        };
         rl.question(`${message} [y/N] `, (answer) => {
+            const normalized = answer.trim().toLowerCase();
+            settle(normalized === "y" || normalized === "yes");
             rl.close();
-            resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
         });
-        rl.on("close", () => resolve(false));
+        rl.once("close", () => settle(false));
     });
 }
 function validateForkFlags(parsed) {
@@ -297,6 +312,22 @@ function validateForkFlags(parsed) {
         process.exit(1);
     }
 }
+function validateRebindFlags(parsed) {
+    if (!parsed.rebind)
+        return;
+    const conflictingFlags = [
+        parsed.session ? "--session" : undefined,
+        parsed.fork ? "--fork" : undefined,
+        parsed.continue ? "--continue" : undefined,
+        parsed.resume ? "--resume" : undefined,
+        parsed.noSession ? "--no-session" : undefined,
+        parsed.sessionId !== undefined ? "--session-id" : undefined,
+    ].filter((flag) => flag !== undefined);
+    if (conflictingFlags.length > 0) {
+        console.error(chalk.red(`Error: --rebind cannot be combined with ${conflictingFlags.join(", ")}`));
+        process.exit(1);
+    }
+}
 function validateSessionIdFlags(parsed) {
     if (parsed.sessionId === undefined)
         return;
@@ -338,6 +369,26 @@ function forkSessionOrExit(sourcePath, cwd, sessionDir, sessionId) {
         process.exit(1);
     }
 }
+async function rebindSessionOrExit(sourcePath, cwd, sessionDir) {
+    try {
+        const reboundPath = await rebindSessionFile(sourcePath, cwd, sessionDir);
+        console.log(chalk.dim(`Session moved to ${cwd}`));
+        return SessionManager.open(reboundPath, sessionDir);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red(`Error: ${message}`));
+        process.exit(1);
+    }
+}
+function sessionCwdOrUndefined(sessionFile) {
+    try {
+        return readSessionCwd(sessionFile);
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function createSessionManager(parsed, cwd, sessionDir, settingsManager, appMode) {
     if (parsed.noSession || parsed.help || parsed.listModels !== undefined || parsed.listTips) {
         return SessionManager.inMemory(cwd, parsed.sessionId !== undefined ? { id: parsed.sessionId } : undefined);
@@ -361,6 +412,22 @@ export async function createSessionManager(parsed, cwd, sessionDir, settingsMana
                 process.exit(1);
         }
     }
+    if (parsed.rebind) {
+        const resolved = await resolveSessionPath(parsed.rebind, cwd, sessionDir);
+        if (resolved.type === "not_found") {
+            console.error(chalk.red(`No session found matching '${resolved.arg}'`));
+            process.exit(1);
+        }
+        const sessionCwd = resolved.type === "global" ? resolved.cwd : sessionCwdOrUndefined(resolved.path);
+        if (resolved.type === "local" || sessionCwd === undefined || resolvePath(sessionCwd) === resolvePath(cwd)) {
+            return openSessionOrExit(resolved.path, sessionDir);
+        }
+        if ((await classifySessionRepository(resolved.path, sessionCwd, cwd)) === "different") {
+            console.error(chalk.red(`Refusing to rebind: ${cwd} is a different git repository than ${sessionCwd}. Use --fork '${parsed.rebind}' to copy the session into this directory instead.`));
+            process.exit(1);
+        }
+        return rebindSessionOrExit(resolved.path, cwd, sessionDir);
+    }
     if (parsed.session) {
         const resolved = await resolveSessionPath(parsed.session, cwd, sessionDir);
         switch (resolved.type) {
@@ -368,23 +435,27 @@ export async function createSessionManager(parsed, cwd, sessionDir, settingsMana
             case "local":
                 return openSessionOrExit(resolved.path, sessionDir);
             case "global": {
-                if (appMode !== "interactive") {
-                    // The fork confirmation below blocks on readline, which only an
-                    // interactive session can answer. Print, JSON, RPC, and app-server runs
-                    // reach here with a TTY attached too (`-p` from a terminal), where the
-                    // question hangs the process or resolves as "no" on stdin EOF. Fail fast
-                    // with an actionable message instead.
-                    console.error(chalk.red(`Session found in different project: ${resolved.cwd}`));
-                    console.error(chalk.red(`Cannot confirm forking without an interactive session. Use --fork '${parsed.session}' to fork it into the current directory, or re-run interactively from ${resolved.cwd}.`));
-                    process.exit(1);
-                }
-                console.log(chalk.yellow(`Session found in different project: ${resolved.cwd}`));
-                const shouldFork = await promptConfirm("Fork this session into current directory?");
-                if (!shouldFork) {
+                // The confirmation blocks on readline, which only an interactive session can
+                // answer. Print, JSON, RPC, and app-server runs reach here with a TTY attached
+                // too (`-p` from a terminal), where the question hangs the process or resolves
+                // as "no" on stdin EOF, so they get the exact commands and a non-zero exit.
+                const action = await chooseCrossProjectAction({
+                    sessionArg: parsed.session,
+                    sessionCwd: resolved.cwd,
+                    cwd,
+                    match: await classifySessionRepository(resolved.path, resolved.cwd, cwd),
+                    interactive: appMode === "interactive",
+                    confirm: promptConfirm,
+                    out: (line) => console.log(line),
+                    err: (line) => console.error(line),
+                });
+                if (action === "rebind")
+                    return rebindSessionOrExit(resolved.path, cwd, sessionDir);
+                if (action === "fork")
+                    return forkSessionOrExit(resolved.path, cwd, sessionDir);
+                if (action === "abort")
                     console.log(chalk.dim("Aborted."));
-                    process.exit(0);
-                }
-                return forkSessionOrExit(resolved.path, cwd, sessionDir);
+                return process.exit(action === "abort" ? 0 : 1);
             }
             case "not_found":
                 console.error(chalk.red(`No session found matching '${resolved.arg}'`));
@@ -394,19 +465,51 @@ export async function createSessionManager(parsed, cwd, sessionDir, settingsMana
     if (parsed.resume) {
         try {
             const { selectSession } = await import("./cli/session-picker.js");
-            const selectedPath = await selectSession((onProgress) => SessionManager.list(cwd, sessionDir, onProgress), (onProgress) => SessionManager.listAll(sessionDir, onProgress), settingsManager);
+            const movedOptions = sessionDir === undefined ? {} : { sessionDir };
+            const selectedPath = await selectSession((onProgress) => withMovedSessions(SessionManager.list(cwd, sessionDir, onProgress), cwd, movedOptions), async (onProgress) => markMovedSessions(await SessionManager.listAll(sessionDir, onProgress), cwd), settingsManager);
             if (!selectedPath) {
                 console.log(chalk.dim("No session selected"));
                 process.exit(0);
             }
-            return SessionManager.open(selectedPath, sessionDir);
+            const target = await resolveResumeTarget({
+                sessionPath: selectedPath,
+                cwd,
+                ...movedOptions,
+                confirm: (selectedCwd) => {
+                    console.log(chalk.yellow(`Session found in different project: ${selectedCwd}`));
+                    return confirmSameRepositoryRebind({
+                        sessionArg: selectedPath,
+                        cwd,
+                        confirm: promptConfirm,
+                        out: (line) => console.log(line),
+                    });
+                },
+            }).catch((error) => {
+                console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+                return process.exit(1);
+            });
+            if (target.rebound)
+                console.log(chalk.dim(`Session moved to ${cwd}`));
+            return SessionManager.open(target.path, sessionDir);
         }
         finally {
             stopThemeWatcher();
         }
     }
     if (parsed.continue) {
-        return SessionManager.continueRecent(cwd, sessionDir);
+        const recent = SessionManager.continueRecent(cwd, sessionDir);
+        const recentFile = recent.getSessionFile();
+        if (recentFile !== undefined && existsSync(recentFile))
+            return recent;
+        const moved = await movedSessionToContinue({
+            cwd,
+            ...(sessionDir === undefined ? {} : { sessionDir }),
+            interactive: appMode === "interactive",
+            confirm: promptConfirm,
+            out: (line) => console.log(line),
+            err: (line) => console.error(line),
+        });
+        return moved === undefined ? recent : rebindSessionOrExit(moved, cwd, sessionDir);
     }
     if (parsed.sessionId) {
         const existingSession = await findLocalSessionByExactId(parsed.sessionId, cwd, sessionDir);
@@ -797,6 +900,7 @@ export async function main(args, options) {
         process.exit(1);
     }
     validateForkFlags(parsed);
+    validateRebindFlags(parsed);
     validateSessionIdFlags(parsed);
     // Run migrations (pass cwd for project-local migrations)
     const { migratedAuthProviders: migratedProviders, deprecationWarnings } = runMigrations(cwd);
@@ -1022,6 +1126,9 @@ export async function main(args, options) {
         }
     }
     time("readPipedStdin");
+    // An RPC process always has a parent that watches its exit; every other mode dies unobserved.
+    recordProcessLifetime(agentDir, appMode, { supervised: appMode === "rpc" });
+    time("recordProcessLifetime");
     const { initialMessage, initialImages, initialTitlePrompt } = await prepareInitialMessage(parsed, settingsManager.getImageAutoResize(), stdinContent);
     time("prepareInitialMessage");
     if (parsed.grokNeo && appMode === "interactive") {