@oh-my-pi/pi-coding-agent 16.1.13 → 16.1.15

package/src/eval/types.ts

@@ -1,16 +1,16 @@
 /** Runtime backend that an eval cell dispatches to. */
-export type EvalLanguage = "python" | "js";
+export type EvalLanguage = "python" | "js" | "ruby" | "julia";
 
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import type { OutputMeta } from "../tools/output-meta";
 
-/** Status event emitted by prelude helpers (python or js) for TUI rendering. */
+/** Status event emitted by eval prelude helpers for TUI rendering. */
 export interface EvalStatusEvent {
 	op: string;
 	[key: string]: unknown;
 }
 
-/** Display output captured during eval execution. Union of python and js shapes. */
+/** Display output captured during eval execution across supported backends. */
 export type EvalDisplayOutput =
 	| { type: "json"; data: unknown }
 	| { type: "image"; data: string; mimeType: string }

package/src/exec/bash-executor.ts

@@ -59,6 +59,42 @@ const shellSessionQuarantines = new Map<string, Promise<unknown>>();
 /** Session keys with a command currently in flight on the persistent Shell. */
 const shellSessionsInUse = new Set<string>();
 
+/**
+ * Shells retained past their turn because a background (`nohup`/`&`) job is
+ * still running. A per-call `:async:` Shell is normally dropped at teardown,
+ * which SIGKILLs its children via kill-on-drop. Keeping the reference alive lets
+ * the process survive across turns; the Shell is dropped once its last
+ * background job exits (reaped by the poll loop below). Children stay
+ * kill-on-drop, so they still die when the harness tears the Shell down on exit.
+ */
+const retainedShells = new Set<Shell>();
+const RETAIN_REAP_INTERVAL_MS = 5_000;
+
+async function retainShellWithLiveBackgroundJobs(shell: Shell): Promise<void> {
+	let live: number;
+	try {
+		live = await shell.liveBackgroundJobCount();
+	} catch {
+		return;
+	}
+	if (live <= 0) return;
+	retainedShells.add(shell);
+	const interval = setInterval(() => {
+		void shell
+			.liveBackgroundJobCount()
+			.then(remaining => {
+				if (remaining > 0) return;
+				clearInterval(interval);
+				retainedShells.delete(shell);
+			})
+			.catch(() => {
+				clearInterval(interval);
+				retainedShells.delete(shell);
+			});
+	}, RETAIN_REAP_INTERVAL_MS);
+	interval.unref?.();
+}
+
 function quarantineShellSession(
 	sessionKey: string,
 	runPromise: Promise<ShellRunResult>,
@@ -411,6 +447,14 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 				// `:async:` keys are per-job (jobId is unique), so the Shell would
 				// otherwise stay in the process-global map forever after completion.
 				shellSessions.delete(sessionKey);
+				// Dropping the only reference to a per-call `:async:` Shell SIGKILLs
+				// any `nohup`/`&` children (kill-on-drop). If the command left a live
+				// background job, retain the Shell so the process survives across
+				// turns; it is reaped once its last job exits and still dies with the
+				// harness. Skip on resetSession (cancel/error) — those tear down.
+				if (!resetSession && shellSession) {
+					await retainShellWithLiveBackgroundJobs(shellSession);
+				}
 			}
 		}
 	}

package/src/export/share.ts

@@ -3,13 +3,13 @@
  *
  * The session JSON is gzipped and sealed with a fresh AES-256-GCM key
  * (`[12B IV][ciphertext+tag]`, same layout as collab frames), then pushed to
- * one of two stores:
+ * one of two stores, chosen by `share.store`:
  *
- *   1. A secret GitHub gist (preferred — free, durable, no relay storage)
- *      holding base64 of the sealed blob, when an authenticated `gh` exists.
- *   2. The share server (`POST <serverUrl>` → `{"id":"…"}`), capped at 1 MB;
- *      oversized sessions are truncated (images first, then long strings,
- *      then oldest entries) until the sealed blob fits.
+ *   1. The share server (default — `POST <serverUrl>` → `{"id":"…"}`), capped
+ *      at 1 MB; oversized sessions are truncated (images first, then long
+ *      strings, then oldest entries) until the sealed blob fits.
+ *   2. A secret GitHub gist (`store: "gist"`, when an authenticated `gh`
+ *      exists; falls back to the share server) holding base64 of the blob.
  *
  * Either way the link is `<serverUrl>/<id>#<base64url key>`. The viewer page
  * served there fetches the blob (gist ids are hex; server ids never are),
@@ -50,9 +50,17 @@ const TEXT_CAPS = [32_768, 8_192, 2_048, 512];
 const BLANK_IMAGE_DATA_URL = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";
 const IMAGE_OMITTED_TEXT = "[image omitted from share]";
 
+export type ShareStore = "blob" | "gist";
+
 export interface ShareSessionOptions {
 	/** Share server/viewer base URL; defaults to {@link DEFAULT_SHARE_URL}. */
 	serverUrl?: string;
+	/**
+	 * Where to upload the sealed blob. `"blob"` (default) posts to the share
+	 * server; `"gist"` pushes to a secret GitHub gist first (needs an
+	 * authenticated `gh`) and falls back to the server.
+	 */
+	store?: ShareStore;
 	/** Agent state for system prompt + tool descriptions in the snapshot. */
 	state?: AgentState;
 	/**
@@ -268,7 +276,7 @@ function redactShareMessage(o: SecretObfuscator, message: AgentMessage): AgentMe
 	}
 }
 
-/** Share the session; tries a secret gist first, then the share server. */
+/** Share the session; uploads to the share server unless `options.store` is `"gist"`. */
 export async function shareSession(sm: SessionManager, options?: ShareSessionOptions): Promise<ShareSessionResult> {
 	const data = buildShareSnapshot(sm, options);
 	const keyBytes = new Uint8Array(SHARE_KEY_BYTES);
@@ -277,29 +285,23 @@ export async function shareSession(sm: SessionManager, options?: ShareSessionOpt
 	const keyText = Buffer.from(keyBytes).toString("base64url");
 	const base = normalizeShareServerUrl(options?.serverUrl);
 
-	const forGist = await sealToFit(key, data, GIST_MAX_SEALED_BYTES);
-	const gist = await tryCreateGist(forGist.sealed);
-	if (gist) {
-		return {
-			url: `${base}/${gist.id}#${keyText}`,
-			method: "gist",
-			gistUrl: gist.url,
-			truncated: forGist.truncated,
-			sealedBytes: forGist.sealed.byteLength,
-		};
+	if (options?.store === "gist") {
+		const forGist = await sealToFit(key, data, GIST_MAX_SEALED_BYTES);
+		const gist = await tryCreateGist(forGist.sealed);
+		if (gist) {
+			return {
+				url: `${base}/${gist.id}#${keyText}`,
+				method: "gist",
+				gistUrl: gist.url,
+				truncated: forGist.truncated,
+				sealedBytes: forGist.sealed.byteLength,
+			};
+		}
+		// gh unusable or gist creation failed — fall back to the share server.
+		return shareViaServer(key, data, base, keyText, forGist);
 	}
 
-	const forServer =
-		forGist.sealed.byteLength <= SERVER_MAX_SEALED_BYTES
-			? forGist
-			: await sealToFit(key, data, SERVER_MAX_SEALED_BYTES);
-	const id = await uploadToServer(forServer.sealed, base);
-	return {
-		url: `${base}/${id}#${keyText}`,
-		method: "server",
-		truncated: forServer.truncated,
-		sealedBytes: forServer.sealed.byteLength,
-	};
+	return shareViaServer(key, data, base, keyText);
 }
 
 /** Strip trailing slashes so `<base>/<id>` composes cleanly. */
@@ -433,6 +435,27 @@ async function tryCreateGist(sealed: Uint8Array): Promise<{ id: string; url: str
 	}
 }
 
+/** Seal to the server cap (reusing `preFit` when it already fits) and upload. */
+async function shareViaServer(
+	key: CryptoKey,
+	data: SessionData,
+	base: string,
+	keyText: string,
+	preFit?: SealedSession,
+): Promise<ShareSessionResult> {
+	const forServer =
+		preFit && preFit.sealed.byteLength <= SERVER_MAX_SEALED_BYTES
+			? preFit
+			: await sealToFit(key, data, SERVER_MAX_SEALED_BYTES);
+	const id = await uploadToServer(forServer.sealed, base);
+	return {
+		url: `${base}/${id}#${keyText}`,
+		method: "server",
+		truncated: forServer.truncated,
+		sealedBytes: forServer.sealed.byteLength,
+	};
+}
+
 /** POST the sealed blob to the share server; returns the assigned id. */
 async function uploadToServer(sealed: Uint8Array, base: string): Promise<string> {
 	let res: Response;

package/src/extensibility/extensions/runner.ts

@@ -10,6 +10,7 @@ import type { Settings } from "../../config/settings";
 import type { MemoryRuntimeContext } from "../../memory-backend";
 import { type Theme, theme } from "../../modes/theme/theme";
 import type { SessionManager } from "../../session/session-manager";
+import type { BranchHandler, NavigateTreeHandler, NewSessionHandler } from "../session-handler-types";
 import { createExtensionModelQuery } from "./model-api";
 import type {
 	AfterProviderResponseEvent,
@@ -141,17 +142,9 @@ type RunnerEmitResult<TEvent extends RunnerEmitEvent> = TEvent extends { type: "
 						? SessionStopEventResult | undefined
 						: undefined;
 
-export type NewSessionHandler = (options?: {
-	parentSession?: string;
-	setup?: (sessionManager: SessionManager) => Promise<void>;
-}) => Promise<{ cancelled: boolean }>;
-
-export type BranchHandler = (entryId: string) => Promise<{ cancelled: boolean }>;
-
-export type NavigateTreeHandler = (
-	targetId: string,
-	options?: { summarize?: boolean },
-) => Promise<{ cancelled: boolean }>;
+// Session-lifecycle handler types live once in session-handler-types (imported
+// above for local use); re-exported here to keep this module's public API stable.
+export type { BranchHandler, NavigateTreeHandler, NewSessionHandler };
 
 export type SwitchSessionHandler = (sessionPath: string) => Promise<{ cancelled: boolean }>;
 

package/src/extensibility/hooks/loader.ts

@@ -11,7 +11,6 @@ import { loadCapability } from "../../discovery";
 // Runtime self-reference: dereference this namespace only inside loader functions to keep the index.ts cycle safe.
 import * as PiCodingAgent from "../../index";
 import type { HookMessage } from "../../session/messages";
-import type { SessionManager } from "../../session/session-manager";
 import * as typebox from "../typebox";
 import { resolvePath } from "../utils";
 import { execCommand } from "./runner";
@@ -35,26 +34,9 @@ export type SendMessageHandler = <T = unknown>(
  */
 export type AppendEntryHandler = <T = unknown>(customType: string, data?: T) => void;
 
-/**
- * New session handler type for ctx.newSession() in HookCommandContext.
- */
-export type NewSessionHandler = (options?: {
-	parentSession?: string;
-	setup?: (sessionManager: SessionManager) => Promise<void>;
-}) => Promise<{ cancelled: boolean }>;
-
-/**
- * Branch handler type for ctx.branch() in HookCommandContext.
- */
-export type BranchHandler = (entryId: string) => Promise<{ cancelled: boolean }>;
-
-/**
- * Navigate tree handler type for ctx.navigateTree() in HookCommandContext.
- */
-export type NavigateTreeHandler = (
-	targetId: string,
-	options?: { summarize?: boolean },
-) => Promise<{ cancelled: boolean }>;
+// Session-lifecycle handler types live once in session-handler-types; re-exported
+// here because hooks/runner.ts imports them from this module.
+export type { BranchHandler, NavigateTreeHandler, NewSessionHandler } from "../session-handler-types";
 
 /**
  * Registered handlers for a loaded hook.

package/src/extensibility/session-handler-types.ts

@@ -0,0 +1,21 @@
+/**
+ * Session-lifecycle handler types shared by the extension runner and the hook
+ * loader/runner. Both surfaces wire the same new-session / branch / navigate
+ * handlers into their command contexts; this is the single source of truth.
+ */
+import type { SessionManager } from "../session/session-manager";
+
+/** Handler for `ctx.newSession()` — creates (and optionally seeds) a session. */
+export type NewSessionHandler = (options?: {
+	parentSession?: string;
+	setup?: (sessionManager: SessionManager) => Promise<void>;
+}) => Promise<{ cancelled: boolean }>;
+
+/** Handler for `ctx.branch()` — branches from a transcript entry. */
+export type BranchHandler = (entryId: string) => Promise<{ cancelled: boolean }>;
+
+/** Handler for `ctx.navigateTree()` — navigates the session tree. */
+export type NavigateTreeHandler = (
+	targetId: string,
+	options?: { summarize?: boolean },
+) => Promise<{ cancelled: boolean }>;