@oh-my-pi/pi-coding-agent 15.5.10 → 15.5.12

package/examples/sdk/13-sql-sessions.ts

@@ -0,0 +1,61 @@
+/**
+ * SQL-Backed Sessions (PostgreSQL / MySQL / SQLite)
+ *
+ * Store session JSONL in a SQL database via `bun:sql`. One table, one row
+ * per session file — works against PostgreSQL, MySQL/MariaDB, and SQLite
+ * with the dialect picked automatically from the connection URL.
+ *
+ * Useful when:
+ * - sessions need to be queryable from existing analytics infra (just JOIN
+ *   against the rest of your warehouse);
+ * - a managed Postgres/MySQL instance is already in place and adding Redis
+ *   isn't worth the operational surface;
+ * - you want a single durable file at rest (SQLite) without coding directly
+ *   against `bun:sqlite`.
+ *
+ * Tool artifacts and image blobs are out of scope: `ArtifactManager` /
+ * `BlobStore` keep writing to `~/.omp/agent/...`. Reach for object storage
+ * if you need those off-host too.
+ */
+
+import { createAgentSession, SessionManager, SqlSessionStorage } from "@oh-my-pi/pi-coding-agent";
+import { SQL } from "bun";
+
+// Pick one — Bun.SQL auto-detects the dialect from the URL scheme.
+//
+//   postgres://user:pass@host:5432/db
+//   mysql://user:pass@host:3306/db
+//   sqlite:/absolute/path/to/sessions.sqlite
+//   sqlite::memory:                                // ephemeral
+const client = new SQL(process.env.SESSIONS_DB_URL ?? "sqlite::memory:");
+
+// `create()` runs `CREATE TABLE IF NOT EXISTS` (with the right DDL for the
+// dialect) and warms the in-memory mirror with every existing row.
+const storage = await SqlSessionStorage.create({
+	client,
+	table: "omp_session_files", // optional, this is the default
+	// createTable: false,       // set if migrations are owned elsewhere
+});
+
+const sessionDir = "/sessions/my-project";
+
+// 1) Fresh persistent session, JSONL backed by SQL.
+const { session } = await createAgentSession({
+	sessionManager: SessionManager.create(process.cwd(), sessionDir, storage),
+});
+console.log(`New SQL session (${storage.adapter}):`, session.sessionFile);
+
+// 2) Continue the most recent session for this `sessionDir`.
+const { session: continued } = await createAgentSession({
+	sessionManager: await SessionManager.continueRecent(process.cwd(), sessionDir, storage),
+});
+console.log("Resumed:", continued.sessionFile);
+
+// 3) Enumerate every session row under this directory prefix.
+const sessions = await SessionManager.list(process.cwd(), sessionDir, storage);
+console.log(`Found ${sessions.length} sessions under ${sessionDir}`);
+
+// On graceful shutdown, drain any background writes the writer queued and
+// close the connection.
+await storage.drain();
+await client.end?.();

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.5.10",
+	"version": "15.5.12",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -47,13 +47,13 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "15.5.10",
-		"@oh-my-pi/omp-stats": "15.5.10",
-		"@oh-my-pi/pi-agent-core": "15.5.10",
-		"@oh-my-pi/pi-ai": "15.5.10",
-		"@oh-my-pi/pi-natives": "15.5.10",
-		"@oh-my-pi/pi-tui": "15.5.10",
-		"@oh-my-pi/pi-utils": "15.5.10",
+		"@oh-my-pi/hashline": "15.5.12",
+		"@oh-my-pi/omp-stats": "15.5.12",
+		"@oh-my-pi/pi-agent-core": "15.5.12",
+		"@oh-my-pi/pi-ai": "15.5.12",
+		"@oh-my-pi/pi-natives": "15.5.12",
+		"@oh-my-pi/pi-tui": "15.5.12",
+		"@oh-my-pi/pi-utils": "15.5.12",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/scripts/build-binary.ts

@@ -56,17 +56,22 @@ async function main(): Promise<void> {
 					"../stats/src/sync-worker.ts",
 					"./src/tools/browser/tab-worker-entry.ts",
 					"./src/eval/js/worker-entry.ts",
-					// Legacy pi-* extension compat shims served by `legacy-pi-compat.ts`.
-					// Both are reached only via the computed `TYPEBOX_SHIM_PATH` /
-					// `LEGACY_PI_AI_SHIM_PATH` constants (which `--compile`'s static
-					// analyzer cannot trace), so each shim must be listed here to land
-					// in bunfs alongside the workers above. The bunfs entry path is
-					// `--root`-relative with a `.js` extension, e.g.
-					// `/$bunfs/root/packages/coding-agent/src/extensibility/typebox.js`,
-					// which is what the `isCompiledBinary()` branch in
-					// `legacy-pi-compat.ts` resolves to at runtime.
+					// Legacy pi-* extension compat entrypoints served by
+					// `legacy-pi-compat.ts`. These are reached via computed bunfs paths
+					// (which `--compile`'s static analyzer cannot trace), so each must be
+					// listed here to land in bunfs at
+					// `/$bunfs/root/packages/<pkg>/<entry>.js`. The coding-agent's own
+					// `./src/index.ts` is intentionally NOT listed: bun --compile silently
+					// breaks the CLI entry when the same package's barrel appears as an
+					// extra entrypoint (issue #1474), so legacy `pi-coding-agent` imports
+					// resolve through `legacy-pi-coding-agent-shim.ts` instead.
+					"../agent/src/index.ts",
+					"../natives/native/index.js",
+					"../tui/src/index.ts",
+					"../utils/src/index.ts",
 					"./src/extensibility/typebox.ts",
 					"./src/extensibility/legacy-pi-ai-shim.ts",
+					"./src/extensibility/legacy-pi-coding-agent-shim.ts",
 					"--outfile",
 					"dist/omp",
 				],

package/src/cli-commands.ts

@@ -0,0 +1,44 @@
+/**
+ * Top-level CLI command table.
+ *
+ * Lives in its own module (importable without side effects) so that tests can
+ * inspect the registered subcommands without triggering the side-effectful
+ * top-level await in `cli.ts`. Adding a new subcommand here is enough to make
+ * `runCli` route to it instead of forwarding the argv as a prompt to
+ * `launch` — see #1496 for the original "args silently leak to the LLM"
+ * regression that motivated the split.
+ */
+import type { CommandEntry } from "@oh-my-pi/pi-utils/cli";
+
+export const commands: CommandEntry[] = [
+	{ name: "launch", load: () => import("./commands/launch").then(m => m.default) },
+	{ name: "acp", load: () => import("./commands/acp").then(m => m.default) },
+	{ name: "auth-broker", load: () => import("./commands/auth-broker").then(m => m.default) },
+	{ name: "auth-gateway", load: () => import("./commands/auth-gateway").then(m => m.default) },
+	{ name: "agents", load: () => import("./commands/agents").then(m => m.default) },
+	{ name: "commit", load: () => import("./commands/commit").then(m => m.default) },
+	{ name: "config", load: () => import("./commands/config").then(m => m.default) },
+	{ name: "grep", load: () => import("./commands/grep").then(m => m.default) },
+	{ name: "grievances", load: () => import("./commands/grievances").then(m => m.default) },
+	{ name: "install", load: () => import("./commands/install").then(m => m.default) },
+	{ name: "plugin", load: () => import("./commands/plugin").then(m => m.default) },
+	{ name: "setup", load: () => import("./commands/setup").then(m => m.default) },
+	{ name: "shell", load: () => import("./commands/shell").then(m => m.default) },
+	{ name: "read", load: () => import("./commands/read").then(m => m.default) },
+	{ name: "ssh", load: () => import("./commands/ssh").then(m => m.default) },
+	{ name: "stats", load: () => import("./commands/stats").then(m => m.default) },
+	{ name: "update", load: () => import("./commands/update").then(m => m.default) },
+	{ name: "worktree", load: () => import("./commands/worktree").then(m => m.default), aliases: ["wt"] },
+	{ name: "search", load: () => import("./commands/web-search").then(m => m.default), aliases: ["q"] },
+];
+
+/**
+ * Return true when `first` matches a registered subcommand name or alias.
+ *
+ * Flags (`-…`) and `@file` arguments are never subcommands; for those the CLI
+ * runner skips ahead to the default `launch` command.
+ */
+export function isSubcommand(first: string | undefined): boolean {
+	if (!first || first.startsWith("-") || first.startsWith("@")) return false;
+	return commands.some(entry => entry.name === first || entry.aliases?.includes(first));
+}

package/src/cli.ts

@@ -10,7 +10,8 @@ procmgr.scrubProcessEnv();
  * CLI entry point — registers all commands explicitly and delegates to the
  * lightweight CLI runner from pi-utils.
  */
-import { type CliConfig, type CommandEntry, run } from "@oh-my-pi/pi-utils/cli";
+import { type CliConfig, run } from "@oh-my-pi/pi-utils/cli";
+import { commands, isSubcommand } from "./cli-commands";
 
 if (Bun.semver.order(Bun.version, MIN_BUN_VERSION) < 0) {
 	process.stderr.write(
@@ -21,27 +22,6 @@ if (Bun.semver.order(Bun.version, MIN_BUN_VERSION) < 0) {
 
 process.title = APP_NAME;
 
-const commands: CommandEntry[] = [
-	{ name: "launch", load: () => import("./commands/launch").then(m => m.default) },
-	{ name: "acp", load: () => import("./commands/acp").then(m => m.default) },
-	{ name: "auth-broker", load: () => import("./commands/auth-broker").then(m => m.default) },
-	{ name: "auth-gateway", load: () => import("./commands/auth-gateway").then(m => m.default) },
-	{ name: "agents", load: () => import("./commands/agents").then(m => m.default) },
-	{ name: "commit", load: () => import("./commands/commit").then(m => m.default) },
-	{ name: "config", load: () => import("./commands/config").then(m => m.default) },
-	{ name: "grep", load: () => import("./commands/grep").then(m => m.default) },
-	{ name: "grievances", load: () => import("./commands/grievances").then(m => m.default) },
-	{ name: "plugin", load: () => import("./commands/plugin").then(m => m.default) },
-	{ name: "setup", load: () => import("./commands/setup").then(m => m.default) },
-	{ name: "shell", load: () => import("./commands/shell").then(m => m.default) },
-	{ name: "read", load: () => import("./commands/read").then(m => m.default) },
-	{ name: "ssh", load: () => import("./commands/ssh").then(m => m.default) },
-	{ name: "stats", load: () => import("./commands/stats").then(m => m.default) },
-	{ name: "update", load: () => import("./commands/update").then(m => m.default) },
-	{ name: "worktree", load: () => import("./commands/worktree").then(m => m.default), aliases: ["wt"] },
-	{ name: "search", load: () => import("./commands/web-search").then(m => m.default), aliases: ["q"] },
-];
-
 async function showHelp(config: CliConfig): Promise<void> {
 	const { renderRootHelp } = await import("@oh-my-pi/pi-utils/cli");
 	const { getExtraHelpText } = await import("./cli/args");
@@ -51,16 +31,6 @@ async function showHelp(config: CliConfig): Promise<void> {
 		process.stdout.write(`\n${extra}\n`);
 	}
 }
-
-/**
- * Determine whether argv[0] is a known subcommand name.
- * If not, the entire argv is treated as args to the default "launch" command.
- */
-function isSubcommand(first: string | undefined): boolean {
-	if (!first || first.startsWith("-") || first.startsWith("@")) return false;
-	return commands.some(e => e.name === first || e.aliases?.includes(first));
-}
-
 /**
  * Smoke-test entry. Spawns the stats sync worker, pings it, exits.
  *

package/src/commands/install.ts

@@ -0,0 +1,107 @@
+/**
+ * `omp install <target>` — top-level convenience over `omp plugin install` /
+ * `omp plugin link`.
+ *
+ * The docs (omp.sh/docs/extension-authoring) advertise
+ *
+ *   omp install ./my-extension
+ *
+ * as a third loading mechanism that "symlinks the directory into the plugin
+ * set and watches it for changes". Before this command existed, `install` was
+ * not a registered subcommand, so the CLI runner forwarded the argv to the
+ * default `launch` command and the model received `install ./my-extension`
+ * as an initial prompt — see #1496.
+ *
+ * Local-path targets (`./foo`, `/abs/foo`, `~/foo`, or an existing directory)
+ * route to `plugin link` so they are symlinked into the plugin set, matching
+ * the documented behavior. Everything else (`pkg`, `pkg@1.2.3`,
+ * `name@marketplace`) routes to `plugin install`.
+ */
+
+import { existsSync } from "node:fs";
+import * as path from "node:path";
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { type PluginAction, type PluginCommandArgs, runPluginCommand } from "../cli/plugin-cli";
+import { initTheme } from "../modes/theme/theme";
+
+/**
+ * Heuristic used to decide whether `omp install <target>` should `link` a
+ * local directory or `install` a remote spec. Exported for tests.
+ */
+export function looksLikeLocalPath(target: string): boolean {
+	if (target.startsWith(".") || target.startsWith("/") || target.startsWith("~")) return true;
+	// Windows drive prefix (e.g. `C:\foo`).
+	if (/^[a-zA-Z]:[\\/]/.test(target)) return true;
+	// Bare names that happen to exist as a local directory.
+	try {
+		return existsSync(path.resolve(target));
+	} catch {
+		return false;
+	}
+}
+
+export default class Install extends Command {
+	static description = "Install or link an extension package (alias of `plugin install`/`plugin link`)";
+
+	static args = {
+		targets: Args.string({
+			description: "Local path, npm spec, or marketplace ref (e.g. ./my-ext, my-pkg@1.2.3, name@marketplace)",
+			required: false,
+			multiple: true,
+		}),
+	};
+
+	static flags = {
+		json: Flags.boolean({ description: "Output JSON" }),
+		force: Flags.boolean({ description: "Force install" }),
+		"dry-run": Flags.boolean({ description: "Show actions without applying changes" }),
+		scope: Flags.string({
+			description: 'Install scope: "user" (default) or "project" (marketplace installs only)',
+			options: ["user", "project"],
+		}),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Install);
+		const targets = Array.isArray(args.targets) ? args.targets : args.targets ? [args.targets] : [];
+
+		if (targets.length === 0) {
+			process.stderr.write("Usage: omp install <path | npm-spec | name@marketplace> [...]\n");
+			process.exit(1);
+		}
+
+		await initTheme();
+
+		// Split into local-paths (→ link) and remote specs (→ install). Each batch
+		// preserves user-supplied order so progress output reads naturally.
+		const localPaths: string[] = [];
+		const remoteSpecs: string[] = [];
+		for (const target of targets) {
+			if (looksLikeLocalPath(target)) localPaths.push(target);
+			else remoteSpecs.push(target);
+		}
+
+		const baseFlags: PluginCommandArgs["flags"] = {
+			json: flags.json,
+			force: flags.force,
+			dryRun: flags["dry-run"],
+			scope: flags.scope as "user" | "project" | undefined,
+		};
+
+		for (const localPath of localPaths) {
+			await runPluginCommand({
+				action: "link" satisfies PluginAction,
+				args: [localPath],
+				flags: baseFlags,
+			});
+		}
+
+		if (remoteSpecs.length > 0) {
+			await runPluginCommand({
+				action: "install" satisfies PluginAction,
+				args: remoteSpecs,
+				flags: baseFlags,
+			});
+		}
+	}
+}

package/src/discovery/index.ts

@@ -32,6 +32,7 @@ import "./gemini";
 import "./opencode";
 import "./github";
 import "./mcp-json";
+import "./omp-plugins";
 import "./ssh";
 import "./vscode";
 import "./windsurf";

package/src/discovery/omp-extension-roots.ts

@@ -0,0 +1,190 @@
+/**
+ * OMP extension package roots.
+ *
+ * An "extension package root" is a directory configured via either
+ * `extensions:` in user/project settings or the `--extension`/`-e` CLI flag
+ * that points to a packaged extension on disk. The package's standard
+ * sub-directories (`skills/`, `hooks/`, `tools/`, `commands/`, `rules/`,
+ * `prompts/`, `.mcp.json`) are wired into discovery by `omp-plugins.ts`.
+ *
+ * CLI-provided paths are injected via {@link injectOmpExtensionCliRoots}
+ * before discovery runs; settings paths are read lazily from
+ * `<scope>/settings.json` in {@link listOmpExtensionRoots} to mirror what
+ * `loadExtensionModules` already does.
+ *
+ * @see ./omp-plugins.ts
+ * @see ./builtin.ts `loadExtensionModules`
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { isEnoent, logger, tryParseJson } from "@oh-my-pi/pi-utils";
+import { readDirEntries, readFile } from "../capability/fs";
+import type { LoadContext } from "../capability/types";
+import { getEnabledPlugins } from "../extensibility/plugins/loader";
+import { expandTilde } from "../tools/path-utils";
+
+/** A resolved extension package directory wired into the discovery surfaces. */
+export interface OmpExtensionRoot {
+	/** Absolute path to the package directory. */
+	path: string;
+	/** Stable display name (basename of the package directory). */
+	name: string;
+	/** Scope from which the path was sourced. */
+	level: "user" | "project";
+}
+
+interface InjectedRoot {
+	path: string;
+	level: "user" | "project";
+}
+
+let injectedCliRoots: InjectedRoot[] = [];
+
+/**
+ * Register CLI-provided extension package paths (e.g. from `--extension`/`-e`)
+ * so the sub-discovery providers can find their sibling `skills/`, `hooks/`,
+ * etc. Paths that do not resolve to a directory are silently dropped — file
+ * entrypoints have no package sub-tree to scan.
+ *
+ * Call once during startup before any capability load. Repeated calls extend
+ * the registered set; {@link clearOmpExtensionCliRoots} resets for tests.
+ */
+export function injectOmpExtensionCliRoots(paths: readonly string[], home: string, cwd: string): void {
+	if (paths.length === 0) return;
+	const expanded = paths.map(raw => {
+		const tilde = expandTilde(raw, home);
+		return path.isAbsolute(tilde) ? tilde : path.resolve(cwd, tilde);
+	});
+	const merged = new Map<string, InjectedRoot>();
+	for (const root of injectedCliRoots) merged.set(root.path, root);
+	for (const resolved of expanded) {
+		// CLI scope mirrors how `--extension` is treated elsewhere — user-level overrides win.
+		if (!merged.has(resolved)) merged.set(resolved, { path: resolved, level: "user" });
+	}
+	injectedCliRoots = [...merged.values()];
+}
+
+/** Drop every CLI-injected root. Tests use this between cases. */
+export function clearOmpExtensionCliRoots(): void {
+	injectedCliRoots = [];
+}
+
+/** Inspect currently-injected CLI roots (read-only). Exposed for diagnostics + tests. */
+export function getInjectedOmpExtensionCliRoots(): readonly OmpExtensionRoot[] {
+	return injectedCliRoots.map(({ path: p, level }) => ({ path: p, level, name: path.basename(p) }));
+}
+
+interface ScopeDirs {
+	project: string;
+	user: string;
+}
+
+function scopeDirs(ctx: LoadContext): ScopeDirs {
+	return {
+		project: path.join(ctx.cwd, ".omp"),
+		user: path.join(ctx.home, ".omp", "agent"),
+	};
+}
+
+async function readSettingsExtensions(settingsPath: string): Promise<string[]> {
+	const content = await readFile(settingsPath);
+	if (!content) return [];
+	const parsed = tryParseJson<{ extensions?: unknown }>(content);
+	const raw = parsed?.extensions;
+	if (!Array.isArray(raw)) return [];
+	return raw.filter((entry): entry is string => typeof entry === "string" && entry.length > 0);
+}
+
+function resolveAgainst(raw: string, ctx: LoadContext): string {
+	const tilde = expandTilde(raw, ctx.home);
+	return path.isAbsolute(tilde) ? tilde : path.resolve(ctx.cwd, tilde);
+}
+
+async function isDirectory(p: string): Promise<boolean> {
+	const entries = await readDirEntries(p);
+	if (entries.length > 0) return true;
+	// Empty directory still counts; cache returns [] for both empty and missing.
+	// Disambiguate with a single stat — only hit when the cached listing is empty.
+	try {
+		const stat = await fs.stat(p);
+		return stat.isDirectory();
+	} catch (err) {
+		if (isEnoent(err)) return false;
+		throw err;
+	}
+}
+
+/**
+ * Resolve every configured extension package directory for the given context.
+ *
+ * Sources, in order of precedence (later entries with the same absolute path
+ * are dropped):
+ *
+ * 1. CLI roots injected via {@link injectOmpExtensionCliRoots}
+ * 2. Project `<cwd>/.omp/settings.json#extensions`
+ * 3. User `~/.omp/agent/settings.json#extensions`
+ * 4. Enabled plugins installed under `<plugins>/node_modules/` (e.g. via
+ *    `omp install <pkg>` / `omp plugin install` / `omp plugin link`)
+ *
+ * Only entries that resolve to a directory on disk are returned; file
+ * entrypoints contribute zero sub-discovery surface and are filtered out.
+ * Installed-plugin enumeration failures (missing lockfile, unreadable
+ * `package.json`, etc.) are logged at `debug` and degrade gracefully — the
+ * other sources still surface.
+ */
+export async function listOmpExtensionRoots(ctx: LoadContext): Promise<OmpExtensionRoot[]> {
+	const { project, user } = scopeDirs(ctx);
+	const [projectExtensions, userExtensions, installedPlugins] = await Promise.all([
+		readSettingsExtensions(path.join(project, "settings.json")),
+		readSettingsExtensions(path.join(user, "settings.json")),
+		listInstalledPluginRoots(ctx),
+	]);
+
+	const candidates: InjectedRoot[] = [
+		...injectedCliRoots,
+		...projectExtensions.map((raw): InjectedRoot => ({ path: resolveAgainst(raw, ctx), level: "project" })),
+		...userExtensions.map((raw): InjectedRoot => ({ path: resolveAgainst(raw, ctx), level: "user" })),
+		...installedPlugins,
+	];
+
+	// First-seen-wins dedup preserves CLI > project-settings > user-settings > installed precedence.
+	const seen = new Set<string>();
+	const unique: InjectedRoot[] = [];
+	for (const candidate of candidates) {
+		if (seen.has(candidate.path)) continue;
+		seen.add(candidate.path);
+		unique.push(candidate);
+	}
+
+	const directoryFlags = await Promise.all(unique.map(c => isDirectory(c.path)));
+	const roots: OmpExtensionRoot[] = [];
+	for (let i = 0; i < unique.length; i++) {
+		if (!directoryFlags[i]) continue;
+		const { path: p, level } = unique[i];
+		roots.push({ path: p, level, name: path.basename(p) });
+	}
+	return roots;
+}
+
+/**
+ * Enumerate every enabled installed plugin's package directory so its
+ * conventional `skills/`, `hooks/`, `tools/`, `commands/`, `rules/`,
+ * `prompts/`, and `.mcp.json` are wired into discovery — mirrors how
+ * `getAllPluginExtensionPaths` already feeds the extension factory loader.
+ *
+ * Marketplace and `omp plugin link` installs write to the plugin manager's
+ * `node_modules` (or symlink into it) rather than to `extensions:` in
+ * settings; without this branch the sub-discovery provider would still miss
+ * everything those install paths produce.
+ */
+async function listInstalledPluginRoots(ctx: LoadContext): Promise<InjectedRoot[]> {
+	try {
+		const plugins = await getEnabledPlugins(ctx.cwd, { home: ctx.home });
+		// Installed plugins are always user-scope; project disablement is already
+		// honored by `getEnabledPlugins` via `loadProjectOverrides`.
+		return plugins.map(({ path: p }) => ({ path: p, level: "user" }));
+	} catch (err) {
+		logger.debug("listInstalledPluginRoots: enumeration failed", { error: String(err) });
+		return [];
+	}
+}