@kr78/pi-coding-agent 17.2.10

package/src/commands/acp.ts

@@ -0,0 +1,35 @@
+/**
+ * Run Oh My Pi as an ACP (Agent Client Protocol) server over stdio.
+ *
+ * Thin wrapper around the launch flow that forces `mode: "acp"` unless the
+ * ACP terminal-auth flag asks the same command to open the interactive TUI.
+ */
+
+import { Command } from "@oh-my-pi/pi-utils/cli";
+import { type Args as ParsedArgs, parseArgs, reportCliUsageError } from "../cli/args";
+import { acpHelp as commandHelp } from "../cli/command-help";
+import { runRootCommand } from "../main";
+import { prepareAcpTerminalAuthArgs } from "../modes/acp/terminal-auth";
+
+export default class Acp extends Command {
+	static description = commandHelp.description;
+	static strict = false;
+
+	async run(): Promise<void> {
+		const { args, terminalAuth } = prepareAcpTerminalAuthArgs(this.argv);
+		let parsed: ParsedArgs;
+		try {
+			parsed = parseArgs(args);
+		} catch (error) {
+			if (reportCliUsageError(error)) {
+				process.exitCode = 2;
+				return;
+			}
+			throw error;
+		}
+		if (!terminalAuth) {
+			parsed.mode = "acp";
+		}
+		await runRootCommand(parsed, args);
+	}
+}

package/src/commands/agents.ts

@@ -0,0 +1,58 @@
+/**
+ * Manage bundled task agents.
+ */
+
+import { Args, Command, Flags, renderCommandHelp } from "@oh-my-pi/pi-utils/cli";
+import { type AgentsAction, type AgentsCommandArgs, runAgentsCommand } from "../cli/agents-cli";
+import { agentsHelp as commandHelp } from "../cli/command-help";
+import { initTheme } from "../modes/theme/theme";
+
+const ACTIONS: AgentsAction[] = ["unpack"];
+
+export default class Agents extends Command {
+	static description = commandHelp.description;
+	static args = {
+		action: Args.string({
+			description: "Agents action",
+			required: false,
+			options: ACTIONS,
+		}),
+	};
+
+	static flags = {
+		force: Flags.boolean({ char: "f", description: "Overwrite existing agent files" }),
+		json: Flags.boolean({ description: "Output JSON" }),
+		dir: Flags.string({ description: "Output directory (overrides --user/--project)" }),
+		user: Flags.boolean({ description: "Write to ~/.omp/agent/agents (default)" }),
+		project: Flags.boolean({ description: "Write to ./.omp/agents" }),
+	};
+
+	static examples = [
+		"# Export bundled agents into user config (default)\n  omp agents unpack",
+		"# Export bundled agents into project config\n  omp agents unpack --project",
+		"# Overwrite existing local agent files\n  omp agents unpack --project --force",
+		"# Export into a custom directory\n  omp agents unpack --dir ./tmp/agents --json",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Agents);
+		if (!args.action) {
+			renderCommandHelp("omp", "agents", Agents);
+			return;
+		}
+
+		const cmd: AgentsCommandArgs = {
+			action: args.action as AgentsAction,
+			flags: {
+				force: flags.force,
+				json: flags.json,
+				dir: flags.dir,
+				user: flags.user,
+				project: flags.project,
+			},
+		};
+
+		await initTheme();
+		await runAgentsCommand(cmd);
+	}
+}

package/src/commands/auth-broker.ts

@@ -0,0 +1,100 @@
+/**
+ * `omp auth-broker` — manage the omp credential vault.
+ */
+
+import { Args, Command, Flags, renderCommandHelp } from "@oh-my-pi/pi-utils/cli";
+import {
+	AUTH_BROKER_ACTIONS,
+	type AuthBrokerAction,
+	type AuthBrokerCommandArgs,
+	runAuthBrokerCommand,
+} from "../cli/auth-broker-cli";
+import { authBrokerHelp as commandHelp } from "../cli/command-help";
+import { initTheme } from "../modes/theme/theme";
+
+export default class AuthBroker extends Command {
+	static description = commandHelp.description;
+	static args = {
+		action: Args.string({
+			description: "Sub-command",
+			required: false,
+			options: [...AUTH_BROKER_ACTIONS],
+		}),
+		// Second positional: provider id (login/logout) or filesystem path (import).
+		source: Args.string({
+			description: "OAuth provider id (login/logout) or path (import)",
+			required: false,
+		}),
+	};
+
+	static flags = {
+		json: Flags.boolean({ description: "Output JSON" }),
+		bind: Flags.string({ description: "Bind address for `serve` (host:port)", char: "b" }),
+		regenerate: Flags.boolean({ description: "Regenerate the bearer token" }),
+		via: Flags.string({
+			description: "SSH user@host for remote login (login --via=user@host)",
+		}),
+		provider: Flags.string({
+			description: "Override provider id for `import` (e.g. when JSON `type` is unrecognized)",
+		}),
+		"include-disabled": Flags.boolean({
+			description: "Import credentials whose JSON has `disabled: true` (import)",
+		}),
+		"from-local": Flags.boolean({
+			description: "migrate source: local SQLite + env vars (required for `migrate`)",
+		}),
+		"include-env": Flags.boolean({
+			description: "Capture env-var API keys for providers not yet on broker (migrate)",
+		}),
+		"include-oauth": Flags.boolean({
+			description: "Also upload OAuth from local SQLite during migrate (default skips them)",
+		}),
+		"dry-run": Flags.boolean({ description: "Print actions without executing (import / login --via / migrate)" }),
+	};
+
+	static examples = [
+		"# Boot the broker against the local SQLite store\n  omp auth-broker serve",
+		"# Boot on a non-default port\n  omp auth-broker serve --bind=127.0.0.1:9000",
+		"# Print the bearer token\n  omp auth-broker token",
+		"# Rotate the bearer token\n  omp auth-broker token --regenerate",
+		"# List supported OAuth providers\n  omp auth-broker list",
+		"# Local login (run on the broker host)\n  omp auth-broker login anthropic",
+		"# Interactive provider selection\n  omp auth-broker login",
+		"# Remote login over SSH tunnel\n  omp auth-broker login anthropic --via=user@broker",
+		"# Log out of a provider (interactive without provider arg)\n  omp auth-broker logout anthropic",
+		"# Import a CLIProxyAPI auth dump\n  omp auth-broker import ~/.cliproxy/auth",
+		"# Import a single CLIProxyAPI JSON, overriding the provider mapping\n  omp auth-broker import ~/.cliproxy/auth/claude-foo.json --provider anthropic",
+		"# Preview a migration from local store + env vars to the configured broker\n  omp auth-broker migrate --from-local --include-env --dry-run",
+		"# Apply the migration\n  omp auth-broker migrate --from-local --include-env",
+		"# Health-check the configured remote broker\n  omp auth-broker status",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(AuthBroker);
+		if (!args.action) {
+			renderCommandHelp("omp", "auth-broker", AuthBroker);
+			return;
+		}
+		const action = args.action as AuthBrokerAction;
+		const cmd: AuthBrokerCommandArgs = {
+			action,
+			flags: {
+				json: flags.json,
+				bind: flags.bind,
+				regenerate: flags.regenerate,
+				via: flags.via,
+				// `login`/`logout` reuse the legacy `provider` slot; `import` keeps `source` separate
+				// so `provider` flag (used as an override) is unambiguous.
+				provider: action === "import" ? flags.provider : (args.source ?? flags.provider),
+				source: args.source,
+				includeDisabled: flags["include-disabled"],
+				fromLocal: flags["from-local"],
+				includeEnv: flags["include-env"],
+				includeOauth: flags["include-oauth"],
+				dryRun: flags["dry-run"],
+			},
+		};
+		await initTheme();
+		await runAuthBrokerCommand(cmd);
+	}
+}

package/src/commands/auth-gateway.ts

@@ -0,0 +1,70 @@
+/**
+ * `omp auth-gateway` — run a forward proxy that injects auth from the broker.
+ */
+
+import { Args, Command, Flags, renderCommandHelp } from "@oh-my-pi/pi-utils/cli";
+import {
+	AUTH_GATEWAY_ACTIONS,
+	type AuthGatewayAction,
+	type AuthGatewayCommandArgs,
+	runAuthGatewayCommand,
+} from "../cli/auth-gateway-cli";
+import { authGatewayHelp as commandHelp } from "../cli/command-help";
+import { initTheme } from "../modes/theme/theme";
+
+export default class AuthGateway extends Command {
+	static description = commandHelp.description;
+	static args = {
+		action: Args.string({
+			description: "Sub-command",
+			required: false,
+			options: [...AUTH_GATEWAY_ACTIONS],
+		}),
+	};
+
+	static flags = {
+		json: Flags.boolean({ description: "Output JSON (token/status/check)" }),
+		bind: Flags.string({ description: "Bind address for `serve` (host:port)", char: "b" }),
+		regenerate: Flags.boolean({ description: "Regenerate the gateway bearer token (token)" }),
+		"no-auth": Flags.boolean({
+			description:
+				"Disable inbound bearer-token auth (serve). Useful when bound to loopback — any caller is allowed.",
+		}),
+		strict: Flags.boolean({
+			description:
+				"For `check`: additionally probe each credential against its provider's chat-completion endpoint. Slower; consumes a tiny amount of quota per credential.",
+		}),
+	};
+
+	static examples = [
+		"# Boot the gateway against the configured broker\n  omp auth-gateway serve",
+		"# Boot on a non-default port\n  omp auth-gateway serve --bind=127.0.0.1:4000",
+		"# Print the gateway bearer token (creates one on first run)\n  omp auth-gateway token",
+		"# Rotate the gateway bearer token\n  omp auth-gateway token --regenerate",
+		"# Run on loopback without any bearer (anyone on this host can call)\n  omp auth-gateway serve --no-auth",
+		"# Show local gateway + broker config status\n  omp auth-gateway status",
+		"# Probe each broker credential to see which one is producing 401s\n  omp auth-gateway check",
+		"# Same, machine-readable for scripts\n  omp auth-gateway check --json",
+		"# Strict check — also exercises each credential with a real chat-completion ping\n  omp auth-gateway check --strict",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(AuthGateway);
+		if (!args.action) {
+			renderCommandHelp("omp", "auth-gateway", AuthGateway);
+			return;
+		}
+		const cmd: AuthGatewayCommandArgs = {
+			action: args.action as AuthGatewayAction,
+			flags: {
+				json: flags.json,
+				bind: flags.bind,
+				regenerate: flags.regenerate,
+				noAuth: flags["no-auth"],
+				strict: flags.strict,
+			},
+		};
+		await initTheme();
+		await runAuthGatewayCommand(cmd);
+	}
+}

package/src/commands/bench.ts

@@ -0,0 +1,64 @@
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { runBenchCommand } from "../cli/bench-cli";
+import { benchHelp as commandHelp } from "../cli/command-help";
+import { SERVICE_TIER_OPENAI_VALUES } from "../config/service-tier";
+
+export default class Bench extends Command {
+	static description = commandHelp.description;
+	static args = {
+		models: Args.string({
+			description: "Model selectors (provider/model or fuzzy id, e.g. opus)",
+			required: true,
+			multiple: true,
+		}),
+	};
+
+	static flags = {
+		runs: Flags.integer({ description: "Requests per model (results are averaged; default: 10)" }),
+		"max-tokens": Flags.integer({ description: "Max output tokens per request (default: 512; cache mode: 64)" }),
+		prompt: Flags.string({ description: "Custom prompt text (default: bundled bench prompt)" }),
+		"service-tier": Flags.string({
+			description: "Service tier applied per model family (default: configured `tier.*` settings; `none` omits it)",
+			options: SERVICE_TIER_OPENAI_VALUES,
+		}),
+		json: Flags.boolean({ description: "Output JSON" }),
+		par: Flags.integer({ description: "Execute runs with N parallel queries/requests (default: 4)" }),
+		cache: Flags.boolean({
+			description: "Run independent cold/warm prompt-cache pairs (not supported for openai-codex-responses)",
+		}),
+		"cache-prefix-file": Flags.string({ description: "Stable prompt prefix file for --cache" }),
+		"cache-prefix-bytes": Flags.integer({ description: "Stable prefix byte budget for --cache (default: 8192)" }),
+		"cache-pairs": Flags.integer({ description: "Cold/warm pairs per model for --cache (default: 1)" }),
+		"cache-concurrency": Flags.integer({
+			description: "Concurrent cache pairs for --cache; each pair remains sequential (default: 1)",
+		}),
+	};
+
+	static examples = [
+		"# Compare two models\n  omp bench anthropic/claude-opus-4-5 openai/gpt-5.2",
+		"# Fuzzy selectors work\n  omp bench opus sonnet",
+		"# Average over 3 runs each\n  omp bench opus gpt-5.2 --runs 3",
+		"# Force priority serving tier\n  omp bench openai-codex/gpt-5.5:low --runs 10 --service-tier priority",
+		"# Measure one cold/warm prompt-cache pair\n  omp bench openai/gpt-5.6 --cache --json",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Bench);
+		await runBenchCommand({
+			models: args.models ?? [],
+			flags: {
+				runs: flags.runs,
+				maxTokens: flags["max-tokens"],
+				prompt: flags.prompt,
+				serviceTier: flags["service-tier"],
+				json: flags.json,
+				par: flags.par,
+				cache: flags.cache,
+				cachePrefixFile: flags["cache-prefix-file"],
+				cachePrefixBytes: flags["cache-prefix-bytes"],
+				cachePairs: flags["cache-pairs"],
+				cacheConcurrency: flags["cache-concurrency"],
+			},
+		});
+	}
+}

package/src/commands/browser-relay.ts

@@ -0,0 +1,53 @@
+/**
+ * `omp browser-relay` — drive the user's own Chrome tabs.
+ */
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import {
+	BROWSER_RELAY_ACTIONS,
+	type BrowserRelayAction,
+	DEFAULT_RELAY_PORT,
+	runBrowserRelayCommand,
+} from "../cli/browser-relay-cli";
+
+export default class BrowserRelay extends Command {
+	static description = "Run the local CDP relay that lets the browser tool drive your own Chrome tabs";
+
+	static args = {
+		action: Args.string({
+			description: `Action: ${BROWSER_RELAY_ACTIONS.join(" | ")} (default serve)`,
+			options: [...BROWSER_RELAY_ACTIONS],
+			required: false,
+		}),
+	};
+
+	static flags = {
+		port: Flags.integer({ char: "p", description: "Port to listen on", default: DEFAULT_RELAY_PORT }),
+		token: Flags.string({ description: "Require the extension to present this token" }),
+		dir: Flags.string({
+			description: "Extension install directory (install; default ~/.omp/browser-relay/extension)",
+		}),
+		"no-group": Flags.boolean({
+			description: "Don't gather controllable tabs into an 'omp' tab group",
+			default: false,
+		}),
+		verbose: Flags.boolean({ char: "v", description: "Log relay traffic summaries to stderr", default: false }),
+	};
+
+	static examples = [
+		"omp browser-relay install    # write the Chrome extension to disk + setup steps",
+		"omp browser-relay            # serve the relay on the default port",
+		"omp browser-relay -p 9333 --token s3cret",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(BrowserRelay);
+		await runBrowserRelayCommand({
+			action: (args.action as BrowserRelayAction | undefined) ?? "serve",
+			port: flags.port,
+			token: flags.token,
+			dir: flags.dir,
+			group: !flags["no-group"],
+			verbose: flags.verbose,
+		});
+	}
+}

package/src/commands/cleanse.ts

@@ -0,0 +1,45 @@
+import { postmortem } from "@oh-my-pi/pi-utils";
+import { Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { runCleanseCommand } from "../cleanse";
+import { cleanseHelp as commandHelp } from "../cli/command-help";
+import { CliUsageError } from "../cli/usage-error";
+
+export default class Cleanse extends Command {
+	static description = commandHelp.description;
+	static flags = {
+		agents: Flags.integer({
+			char: "n",
+			description: "Maximum number of file-disjoint subagents",
+			default: 8,
+		}),
+		model: Flags.string({
+			char: "m",
+			description: "Subagent model selector",
+			default: "@smol",
+		}),
+		tests: Flags.boolean({
+			char: "t",
+			description: "Also run configured project test suites",
+			default: false,
+		}),
+	};
+
+	static examples = [
+		"omp cleanse",
+		"omp cleanse -n 4",
+		"omp cleanse -m opus",
+		"omp cleanse -t",
+		"omp cleanse --agents 12 --model anthropic/claude-opus-4-6",
+	];
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(Cleanse);
+		if (flags.agents <= 0) throw new CliUsageError("--agents must be a positive integer");
+		const result = await runCleanseCommand({
+			maxAgents: flags.agents,
+			model: flags.model,
+			includeTests: flags.tests,
+		});
+		await postmortem.quit(result.exitCode);
+	}
+}

package/src/commands/commit.ts

@@ -0,0 +1,47 @@
+/**
+ * Generate and optionally push a commit with changelog updates.
+ */
+
+import { postmortem } from "@oh-my-pi/pi-utils";
+import { Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { commitHelp as commandHelp } from "../cli/command-help";
+import { runCommitCommand } from "../commit";
+import type { CommitCommandArgs } from "../commit/types";
+import { initTheme } from "../modes/theme/theme";
+
+export default class Commit extends Command {
+	static description = commandHelp.description;
+	static flags = {
+		push: Flags.boolean({ description: "Push after committing" }),
+		"dry-run": Flags.boolean({ description: "Preview without committing" }),
+		"no-changelog": Flags.boolean({ description: "Skip changelog updates" }),
+		legacy: Flags.boolean({ description: "Use legacy deterministic pipeline" }),
+		context: Flags.string({ char: "c", description: "Additional context for the model" }),
+		model: Flags.string({ char: "m", description: "Override model selection" }),
+	};
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(Commit);
+
+		const cmd: CommitCommandArgs = {
+			push: flags.push ?? false,
+			dryRun: flags["dry-run"] ?? false,
+			noChangelog: flags["no-changelog"] ?? false,
+			legacy: flags.legacy,
+			context: flags.context,
+			model: flags.model,
+		};
+
+		await initTheme();
+		// The agentic commit flow opens keep-alive sockets to the model provider
+		// and spins up an AgentSession with background async-job + extension
+		// machinery. `session.dispose()` releases what it can, but Bun's fetch
+		// keeps idle connections warm and a few timers (Settings autosave, OAuth
+		// refresh) stay armed long enough to pin the event loop after the commit
+		// is already written. Mirror the `runPrintMode` exit pattern from
+		// `main.ts` so the CLI returns to the shell instead of stranding the user
+		// on Ctrl+C (issue #1041).
+		await runCommitCommand(cmd);
+		await postmortem.quit(0);
+	}
+}

package/src/commands/complete.ts

@@ -0,0 +1,67 @@
+/**
+ * `omp __complete <kind> [-- <prefix>]` — dynamic completion candidates.
+ *
+ * Hidden helper invoked by the generated shell completion scripts to resolve
+ * values that can't be baked into the script: the live model catalog and
+ * on-disk sessions. Output is one `value\tdescription` line per candidate
+ * (tab-separated); shells that show descriptions parse the tab, bash uses the
+ * first field. The import surface is kept deliberately narrow so a TAB press
+ * doesn't pay for the full agent boot.
+ */
+import { type GeneratedProvider, getBundledModels, getBundledProviders } from "@oh-my-pi/pi-catalog/models";
+import { Command } from "@oh-my-pi/pi-utils/cli";
+import { completeHelp as commandHelp } from "../cli/command-help";
+import { SessionManager } from "../session/session-manager";
+
+export default class Complete extends Command {
+	static hidden = commandHelp.hidden;
+	static strict = false;
+
+	async run(): Promise<void> {
+		const argv = this.argv.filter(token => token !== "--");
+		const kind = argv[0];
+		const prefix = argv.length > 1 ? argv[argv.length - 1] : "";
+		if (kind === "models") {
+			completeModels(prefix);
+		} else if (kind === "sessions") {
+			await completeSessions(prefix);
+		}
+	}
+}
+
+/** Strip control chars that would corrupt the tab-separated line protocol. */
+function clean(text: string): string {
+	return text.replace(/[\t\r\n]+/g, " ").trim();
+}
+
+function completeModels(prefix: string): void {
+	const needle = prefix.toLowerCase();
+	const seen = new Set<string>();
+	const lines: string[] = [];
+	for (const provider of getBundledProviders()) {
+		for (const model of getBundledModels(provider as GeneratedProvider)) {
+			// Offer both the fully-qualified `provider/id` and the bare `id`
+			// (matches the fuzzy resolution `--model` accepts).
+			const candidates = [`${model.provider}/${model.id}`, model.id];
+			for (const candidate of candidates) {
+				if (seen.has(candidate)) continue;
+				seen.add(candidate);
+				if (needle && !candidate.toLowerCase().includes(needle)) continue;
+				lines.push(`${candidate}\t${model.provider}`);
+			}
+		}
+	}
+	lines.sort();
+	if (lines.length > 0) process.stdout.write(`${lines.join("\n")}\n`);
+}
+
+async function completeSessions(prefix: string): Promise<void> {
+	const sessions = await SessionManager.list(process.cwd());
+	const lines: string[] = [];
+	for (const session of sessions) {
+		if (prefix && !session.id.startsWith(prefix)) continue;
+		const label = clean(session.title ?? session.firstMessage ?? "").slice(0, 72);
+		lines.push(`${session.id}\t${label}`);
+	}
+	if (lines.length > 0) process.stdout.write(`${lines.join("\n")}\n`);
+}

package/src/commands/completions.ts

@@ -0,0 +1,61 @@
+/**
+ * `omp completions <bash|zsh|fish>` — print a shell completion script.
+ *
+ * The script is derived entirely from the declarative command/flag metadata
+ * (see `cli/completion-gen.ts`), so it never drifts from the actual CLI surface.
+ */
+
+import { APP_NAME, VERSION } from "@oh-my-pi/pi-utils";
+import { Args, type CliConfig, Command, type CommandCtor } from "@oh-my-pi/pi-utils/cli";
+import { completionsHelp as commandHelp } from "../cli/command-help";
+import { buildSpec, generateCompletion, type Shell } from "../cli/completion-gen";
+import { commands } from "../cli-commands";
+
+/** Entry name of the default command whose flags become top-level completions. */
+const ROOT_COMMAND = "launch";
+const SHELLS = ["bash", "zsh", "fish"] as const;
+
+export default class Completions extends Command {
+	static description = commandHelp.description;
+	static args = {
+		shell: Args.string({
+			description: "Target shell",
+			required: true,
+			options: SHELLS,
+		}),
+	};
+
+	static examples = [
+		`# zsh — eval at startup, or write to a file in $fpath\n  eval "$(${APP_NAME} completions zsh)"`,
+		`# bash\n  eval "$(${APP_NAME} completions bash)"`,
+		`# fish\n  ${APP_NAME} completions fish > ~/.config/fish/completions/${APP_NAME}.fish`,
+	];
+
+	async run(): Promise<void> {
+		const shell = this.argv[0];
+		if (!isShell(shell)) {
+			process.stderr.write(`Usage: ${APP_NAME} completions <${SHELLS.join("|")}>\n`);
+			process.exitCode = 1;
+			return;
+		}
+
+		// Load every command class so we can read its static flag/arg descriptors,
+		// and collect aliases from both the registration table and the class.
+		const loaded = await Promise.all(commands.map(async entry => ({ entry, Cmd: await entry.load() })));
+		const map = new Map<string, CommandCtor>();
+		const aliasMap = new Map<string, readonly string[]>();
+		for (const { entry, Cmd } of loaded) {
+			map.set(entry.name, Cmd);
+			const merged = new Set<string>([...(Cmd.aliases ?? []), ...(entry.aliases ?? [])]);
+			aliasMap.set(entry.name, [...merged]);
+		}
+
+		const config: CliConfig = { bin: APP_NAME, version: VERSION, commands: map };
+		const spec = buildSpec(config, ROOT_COMMAND, aliasMap);
+		await Bun.write(Bun.stdout, generateCompletion(shell, spec));
+	}
+}
+
+function isShell(value: string | undefined): value is Shell {
+	return value === "bash" || value === "zsh" || value === "fish";
+}

package/src/commands/config.ts

@@ -0,0 +1,52 @@
+/**
+ * Manage configuration settings.
+ */
+
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { configHelp as commandHelp } from "../cli/command-help";
+import { type ConfigAction, type ConfigCommandArgs, runConfigCommand } from "../cli/config-cli";
+import { initTheme } from "../modes/theme/theme";
+
+const ACTIONS: ConfigAction[] = ["list", "get", "set", "reset", "path", "init-xdg"];
+
+export default class Config extends Command {
+	static description = commandHelp.description;
+	static args = {
+		action: Args.string({
+			description: "Config action",
+			required: false,
+			options: ACTIONS,
+		}),
+		key: Args.string({
+			description: "Setting key",
+			required: false,
+		}),
+		value: Args.string({
+			description: "Value (for set/reset)",
+			required: false,
+			multiple: true,
+		}),
+	};
+
+	static flags = {
+		json: Flags.boolean({ description: "Output JSON" }),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Config);
+		const action = (args.action ?? "list") as ConfigAction;
+		const value = Array.isArray(args.value) ? args.value.join(" ") : args.value;
+
+		const cmd: ConfigCommandArgs = {
+			action,
+			key: args.key,
+			value,
+			flags: {
+				json: flags.json,
+			},
+		};
+
+		await initTheme();
+		await runConfigCommand(cmd);
+	}
+}