@sentropic/h2a-runtime 0.94.3 → 0.96.0

package/dist/index.js

@@ -9,6 +9,7 @@ import { Command, Help } from "commander";
 import { applyRuntimeHelpGroups, groupRuntimeHelpItems, } from "./cli-help-groups.js";
 import { attach, createRemoteSession, getRemoteSession, listRemoteSessions, refreshRemoteSession, renameRemoteSession, sessionTerminalHealth, stopRemoteSession, } from "./attach.js";
 import { authHeaders, clearDefaultRemote, getDefaultRemote, getDefaultTarget, getDefaultTools, getH2aConfig, getJobMaxAgeHours, getMaxConcurrent, getLlmMeshRuntimeConfig, getTmuxProfileConfig, getTunnel, resolveConfigPath, setDefaultRemote, setDefaultTarget, migrateConfigHomeIfNeeded, setDefaultTools, setLlmMeshRuntimeConfig, setTmuxProfileConfig, setToken, setTunnel, } from "./config.js";
+import { prepareCentralMcpForLaunch, prepareCentralMcpForRestore, } from "./central-mcp.js";
 import { ensureConnected, stopTunnel } from "./tunnel.js";
 import { detectToolAuth, KNOWN_TOOLS, partitionTools } from "./auth-tools.js";
 import { transmittedSecrets, secretsSummary } from "./secrets.js";
@@ -18,7 +19,8 @@ import { syncConversation } from "./sync.js";
 import { attachLocalSession, attachPodTmux, capturePane, capturePaneVisible, clearPaneComposer, conductorRunning, currentTmuxSessionName, currentTmuxSessionIs, ensureManagedTmuxProfile, ensureHeadlessTerminal, existingLocalSessionSlugs, fanoutLabels, findLocalSession, killLocalSession, localSessionGatewayEnvStatus, listLocalSessions, listH2aStatusSurfaces, listLocalSessionsWithDiagnostics, localSessionIdle, localSessionPanePid, localSessionName, paneProcessObservation, paneTreeCpuMs, paneWorkerAttribution, paneWorkerAttributionFromView, paneWorkerPid, pasteLiteralBlock, submitPane, installH2aStatusSurface, managedSessionCandidates, parseManagedSessionName, openH2aStatusWindow, persistLaunchContext, readLaunchContext, readFleetProcView, relaunchInSession, resolveAgentPane, resolveAgentPaneForInstance, resolveLocalSession, sessionRelaunchSafety, runLocalCliForeground, sendKeysLiteral, sessionAttached, sessionAttachedCount, setLocalSessionDisplayName, slugify, cleanupHeadlessPromptFile, startH2aWindow, startH2aWindowVerified, startHeadlessSession, startLocalSession, tmuxAvailable, uninstallH2aStatusSurface, } from "./tmux.js";
 import { deliverInitialPrompt, sleepSync, } from "./prompt-delivery.js";
 import { buildLaunchContext } from "./launch-context.js";
-import { attachNativeSession, killNativeSessionTree, nativeHostAvailable, nativePromptDeliveryDeps, nativeSessionLiveness, nativeSessionPid, nativeTreeCpuMs, nativeWorkerPid, resolveSessionHostKind, startNativeH2aSidecar, startNativeHeadlessSession, startNativeSession, } from "./native-host.js";
+import { attachNativeSession, driveNativeInstruction, killNativeSessionIfIncarnation, killNativeSessionTree, nativeHostAvailable, nativePromptDeliveryDeps, nativeSessionLiveness, nativeSessionPid, nativeSessionState, nativeTreeCpuMs, nativeWorkerPid, resolveSessionHostKind, startNativeH2aSidecar, startNativeHeadlessSession, startNativeSession, } from "./native-host.js";
+import { executeNativeRestart, NativeRestartError, } from "./native-restart.js";
 import { migrateTmuxNames } from "./tmux-name-migration.js";
 import { projectStatusForH2a } from "./status-projection.js";
 import { buildAgentLaunchArgs, isAgentLaunchEffort, isAgentLaunchProfile, } from "./agent-launch-args.js";
@@ -74,6 +76,7 @@ const KNOWN_PROFILE_HELP = `${CLI_PROFILES.join(", ")} (aliases: claude-code, an
 export const packageName = "@sentropic/h2a-runtime";
 export const H2A_RUNTIME_CLI_API_VERSION = 1;
 export { run } from "./run.js";
+export { executeNativeRestart, nativeMcpRelaunchInstruction, NativeRestartError, } from "./native-restart.js";
 export { AGENT_LAUNCH_EFFORTS, AGENT_LAUNCH_PROFILES, AGENT_LAUNCH_PROMPT_MAX_BYTES, assertAgentLaunchModel, assertAgentLaunchPrompt, buildAgentLaunchArgs, isAgentLaunchEffort, isAgentLaunchProfile, } from "./agent-launch-args.js";
 export { attach, createRemoteSession, getRemoteSession, listRemoteSessions, refreshRemoteSession, renameRemoteSession, stopRemoteSession, } from "./attach.js";
 export { inspectProfileAuth } from "./auth-diagnostics.js";
@@ -1401,6 +1404,64 @@ async function injectLlmMeshGatewayEnv(mode = "auto", allowDirectFallback = true
     }
     return meshEnv.ANTHROPIC_BASE_URL;
 }
+function captureAnthropicGatewayEnvironment() {
+    return {
+        ...(process.env.ANTHROPIC_BASE_URL !== undefined
+            ? { ANTHROPIC_BASE_URL: process.env.ANTHROPIC_BASE_URL }
+            : {}),
+        ...(process.env.ANTHROPIC_AUTH_TOKEN !== undefined
+            ? { ANTHROPIC_AUTH_TOKEN: process.env.ANTHROPIC_AUTH_TOKEN }
+            : {}),
+        ...(process.env.ANTHROPIC_API_KEY !== undefined
+            ? { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY }
+            : {}),
+    };
+}
+async function prepareNativeRestart(session, mode) {
+    if (mode === "gateway" && !profileUsesLlmMeshGateway(session.profile)) {
+        throw new Error("gateway is unsupported for this profile");
+    }
+    const original = captureAnthropicGatewayEnvironment();
+    const restore = replaceAnthropicGatewayEnvironment(process.env, original);
+    try {
+        const effectiveMode = gatewayModeForProfile(session.profile, mode);
+        await injectLlmMeshGatewayEnv(effectiveMode, effectiveMode !== "gateway", session.name);
+        const useBare = shouldUseClaudeBare(session.profile);
+        return {
+            command: localCliCommand(session.profile),
+            args: session.convId
+                ? localResumeArgs(session.profile, session.convId, { bare: useBare })
+                : localStartArgs(session.profile, { bare: useBare }),
+            gatewayEnvironment: captureAnthropicGatewayEnvironment(),
+        };
+    }
+    finally {
+        restore();
+    }
+}
+function renderNativeRestartResult(result, json) {
+    if (json) {
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+        return;
+    }
+    for (const row of result.sessions) {
+        if (row.state === "completed") {
+            if (row.restarted) {
+                process.stderr.write(`[h2a] restarted native CLI ${row.id} (gateway=${row.gatewayMode})\n`);
+            }
+            if (row.instructionSubmitted) {
+                process.stderr.write(`[h2a] submitted MCP relaunch/attach instruction to ${row.id}; MCP health is not yet proven\n`);
+            }
+            continue;
+        }
+        if (row.state === "failed") {
+            process.stderr.write(`[h2a] restart failed for ${row.id} (${row.failure ?? "unknown"})\n`);
+        }
+        else {
+            process.stderr.write(`[h2a] restart did not touch ${row.id} because an earlier session failed\n`);
+        }
+    }
+}
 export async function prepareStructuredGateway(mode, inject = (selectedMode) => injectLlmMeshGatewayEnv(selectedMode, selectedMode !== "gateway")) {
     const gateway = await inject(mode);
     if (mode === "gateway" && !gateway) {
@@ -4062,6 +4123,14 @@ export async function main(argv) {
             process.exitCode = 2;
             return;
         }
+        try {
+            await prepareCentralMcpForLaunch({ root: cwd, profile, cwd });
+        }
+        catch (error) {
+            process.stderr.write(`[h2a] ${error.message}\n`);
+            process.exitCode = 1;
+            return;
+        }
         const started = [];
         for (const label of labels) {
             const clientSessionId = localSessionName(slugify(label ?? cwd));
@@ -5773,6 +5842,121 @@ export async function main(argv) {
         process.stderr.write("[h2a] wake-request watch stopped\n");
     });
     // ---------------------------------------------------------------------------
+    // restart — explicit native CLI recreation or guarded live MCP instruction
+    // ---------------------------------------------------------------------------
+    program
+        .command("restart [session]")
+        .description("Restart one live managed native-PTY CLI, or every live managed native CLI with --all. --gw requires the explicit value on|off. With --relaunch-mcp alone, keep the CLI alive and submit one guarded MCP relaunch/attach instruction through the native drive backchannel.")
+        .option("--all", "target every live managed native CLI session")
+        .option("--gw <on|off>", "restart with llm-mesh gateway explicitly on or off")
+        .option("--relaunch-mcp <name>", "submit a bounded instruction to relaunch or attach this MCP server; submission does not prove MCP health")
+        .option("--json", "emit a versioned, credential-free result")
+        .action(async (session, opts) => {
+        try {
+            const registry = loadRegistry();
+            if (registry.state === "unknown") {
+                throw new NativeRestartError("registry-unreadable", `local registry is unreadable (${registry.reason})`);
+            }
+            const candidates = registry.entries.map((entry) => ({
+                id: entry.id,
+                ...(entry.label !== undefined ? { label: entry.label } : {}),
+                name: entry.tmuxSession ?? localSessionName(entry.id),
+                kind: entry.kind,
+                ...(entry.role !== undefined ? { role: entry.role } : {}),
+                ...(entry.endedAt !== undefined ? { endedAt: entry.endedAt } : {}),
+                profile: entry.tool,
+                cwd: entry.cwd,
+                ...(entry.convId !== undefined ? { convId: entry.convId } : {}),
+                ...(entry.sessionClass !== undefined
+                    ? { sessionClass: entry.sessionClass }
+                    : {}),
+                ...(entry.gatewayMode !== undefined
+                    ? { gatewayMode: entry.gatewayMode }
+                    : {}),
+            }));
+            const result = await executeNativeRestart({
+                ...(session !== undefined ? { target: session } : {}),
+                ...(opts.all === true ? { all: true } : {}),
+                ...(opts.gw !== undefined
+                    ? { gateway: opts.gw }
+                    : {}),
+                ...(opts.relaunchMcp !== undefined
+                    ? { relaunchMcp: opts.relaunchMcp }
+                    : {}),
+            }, {
+                listSessions: () => candidates,
+                snapshot: (candidate) => {
+                    const probe = nativeSessionState(candidate.name);
+                    if (probe.state === "unknown")
+                        return { state: "unknown" };
+                    if (probe.state === "absent" ||
+                        probe.session.status !== "running") {
+                        return { state: "dead" };
+                    }
+                    return {
+                        state: "live",
+                        generation: probe.session.generation,
+                        incarnation: probe.session.incarnation,
+                        controlled: probe.session.controlled ?? true,
+                    };
+                },
+                prepare: (candidate, _snapshot, mode) => prepareNativeRestart(candidate, mode),
+                restart: (candidate, snapshot, mode, prepared) => {
+                    if (!killNativeSessionIfIncarnation(candidate.name, snapshot.generation, snapshot.incarnation)) {
+                        throw new Error("fenced native stop failed");
+                    }
+                    const restore = replaceAnthropicGatewayEnvironment(process.env, prepared.gatewayEnvironment);
+                    try {
+                        const relaunched = startNativeSession(candidate.profile, prepared.command, candidate.cwd, prepared.args, candidate.id, {
+                            ...(candidate.convId !== undefined
+                                ? { resumeId: candidate.convId }
+                                : {}),
+                            sessionClass: candidate.sessionClass ?? "human",
+                            refuseExisting: true,
+                        });
+                        enrollFromRun({
+                            profile: candidate.profile,
+                            slug: candidate.id,
+                            tmuxSession: relaunched.name,
+                            hostKind: "local-native",
+                            pid: relaunched.pid,
+                            cwd: candidate.cwd,
+                            sessionClass: candidate.sessionClass ?? "human",
+                            ...(candidate.convId !== undefined
+                                ? { convId: candidate.convId }
+                                : {}),
+                            ...(mode !== "auto" ? { gatewayMode: mode } : {}),
+                        });
+                    }
+                    finally {
+                        restore();
+                    }
+                },
+                drive: (candidate, instruction) => driveNativeInstruction(candidate.id, instruction),
+            });
+            renderNativeRestartResult(result, opts.json === true);
+            if (!result.ok)
+                process.exitCode = 1;
+        }
+        catch (error) {
+            const known = error instanceof NativeRestartError;
+            const code = known ? error.code : "restart-internal";
+            const message = known ? error.message : "restart failed unexpectedly";
+            if (opts.json === true) {
+                process.stdout.write(`${JSON.stringify({
+                    kind: "h2a.restart.result",
+                    version: 1,
+                    ok: false,
+                    error: { code, message },
+                })}\n`);
+            }
+            else {
+                process.stderr.write(`[h2a] restart: ${message}\n`);
+            }
+            process.exitCode = 1;
+        }
+    });
+    // ---------------------------------------------------------------------------
     // relaunch — recover idle sessions, or explicitly force-recreate one/all
     // ---------------------------------------------------------------------------
     program
@@ -6511,6 +6695,14 @@ export async function main(argv) {
         }
         if (forceGateway)
             restoreOpts.forceGateway = forceGateway;
+        try {
+            await prepareCentralMcpForRestore({ root: process.cwd() });
+        }
+        catch (error) {
+            process.stderr.write(`[h2a] ${error.message}\n`);
+            process.exitCode = 1;
+            return;
+        }
         if (needRemote) {
             const url = getConfiguredRemote();
             await ensureConnected(url);
@@ -7368,6 +7560,7 @@ if (isEntryPoint()) {
 export { main as dispatchH2a };
 /** @deprecated Compatibility for older h2a cores; new cores require dispatchH2a. */
 export { main as dispatch };
+export { ensureCentralMcp } from "./central-mcp.js";
 /**
  * h2a-facing surface: the read-only remote-agents projection consumed by the
  * objective-loop tick's *agents adapter* in `@sentropic/h2a` (via lazy
@@ -7382,6 +7575,7 @@ export { projectStatusForH2a };
 export { NativeTerminalClient } from "./native-terminal/client.js";
 export { NativeTerminalHost } from "./native-terminal/host.js";
 export { NativeTerminalHostSupervisor } from "./native-terminal/supervisor.js";
+export { assertOwnedByCurrentUser, sameNativeTerminalSocket } from "./native-terminal/socket-path.js";
 /**
  * Status-bar writer surface, consumed by `@sentropic/h2a`'s
  * `status --write-bars` loop via lazy `import()`: enumerate the sessions whose