@sayknow-cli/coding-agent 0.3.15 → 0.4.0

package/src/cli/args.ts

@@ -1,6 +1,7 @@
 /**
  * CLI argument parsing and help display
  */
+import * as path from "node:path";
 import { type Effort, THINKING_EFFORTS } from "@sayknow-cli/ai";
 import { APP_NAME, CONFIG_DIR_NAME, logger } from "@sayknow-cli/utils";
 import { CliParseError } from "@sayknow-cli/utils/cli";
@@ -8,7 +9,7 @@ import chalk from "chalk";
 import { parseEffort } from "../thinking";
 import { BUILTIN_TOOLS } from "../tools";
 
-export type Mode = "text" | "json" | "rpc" | "acp" | "rpc-ui" | "bridge";
+export type Mode = "text" | "json" | "acp";
 
 export interface Args {
 	cwd?: string;
@@ -24,6 +25,7 @@ export interface Args {
 	credential?: string;
 	systemPrompt?: string;
 	appendSystemPrompt?: string;
+	mcpConfig?: string;
 	thinking?: Effort;
 	continue?: boolean;
 	resume?: string | true;
@@ -32,7 +34,6 @@ export interface Args {
 	mode?: Mode;
 	noSession?: boolean;
 	sessionDir?: string;
-	rpcListen?: string;
 	providerSessionId?: string;
 	fork?: string;
 	models?: string[];
@@ -58,6 +59,8 @@ export interface Args {
 	fileArgs: string[];
 	/** Retained for test/runtime compatibility; extension-defined flags are no longer parsed. */
 	unknownFlags: Map<string, boolean | string>;
+	/** Exact interactive startup login intent, recognized before model-profile activation. */
+	authBootstrap?: true;
 }
 
 function isStartupSlashCommandArg(arg: string | undefined): boolean {
@@ -69,6 +72,13 @@ function isStartupSlashCommandArg(arg: string | undefined): boolean {
 	);
 }
 
+function isStartupLoginCommandArg(args: readonly string[], index: number): boolean {
+	const command = args[index];
+	if (command !== "/login" && command !== "login") return false;
+	const argumentCount = args.length - index - 1;
+	return argumentCount === 0 || (argumentCount === 1 && !args[index + 1].startsWith("-"));
+}
+
 export function parseArgs(args: string[]): Args {
 	const result: Args = {
 		messages: [],
@@ -79,6 +89,12 @@ export function parseArgs(args: string[]): Args {
 	for (let i = 0; i < args.length; i++) {
 		let arg = args[i];
 
+		if (isStartupLoginCommandArg(args, i)) {
+			result.authBootstrap = true;
+			const loginCommand = arg === "login" ? "/login" : arg;
+			result.messages.push([loginCommand, ...args.slice(i + 1)].join(" "));
+			break;
+		}
 		if (isStartupSlashCommandArg(arg)) {
 			result.messages.push(args.slice(i).join(" "));
 			break;
@@ -101,15 +117,15 @@ export function parseArgs(args: string[]): Args {
 			result.allowHome = true;
 		} else if (arg === "--mode" && i + 1 < args.length) {
 			const mode = args[++i];
-			if (
-				mode === "text" ||
-				mode === "json" ||
-				mode === "rpc" ||
-				mode === "acp" ||
-				mode === "rpc-ui" ||
-				mode === "bridge"
-			) {
+			if (mode === "text" || mode === "json" || mode === "acp") {
 				result.mode = mode;
+			} else {
+				const removed = mode === "rpc" || mode === "rpc-ui" || mode === "bridge";
+				throw new CliParseError(
+					removed
+						? `--mode ${mode} was removed; external control now uses the Sayknow-CLI SDK (docs/sdk.md)`
+						: `invalid --mode value: ${mode} (expected text, json, or acp)`,
+				);
 			}
 		} else if (arg === "--continue" || arg === "-c") {
 			result.continue = true;
@@ -148,14 +164,21 @@ export function parseArgs(args: string[]): Args {
 			result.systemPrompt = args[++i];
 		} else if (arg === "--append-system-prompt" && i + 1 < args.length) {
 			result.appendSystemPrompt = args[++i];
+		} else if (arg === "--mcp-config") {
+			if (result.mcpConfig !== undefined) {
+				throw new CliParseError("--mcp-config can only be specified once");
+			}
+			const next = args[i + 1];
+			if (!next || next.startsWith("-") || !path.isAbsolute(next)) {
+				throw new CliParseError("--mcp-config requires <absolute-path>");
+			}
+			result.mcpConfig = args[++i];
 		} else if (arg === "--provider-session-id" && i + 1 < args.length) {
 			result.providerSessionId = args[++i];
 		} else if (arg === "--no-session") {
 			result.noSession = true;
 		} else if (arg === "--session-dir" && i + 1 < args.length) {
 			result.sessionDir = args[++i];
-		} else if (arg === "--listen" && i + 1 < args.length) {
-			result.rpcListen = args[++i];
 		} else if (arg === "--models" && i + 1 < args.length) {
 			result.models = args[++i].split(",").map(s => s.trim());
 		} else if (arg === "--no-tools") {
@@ -219,6 +242,14 @@ export function parseArgs(args: string[]): Args {
 	if (result.default && !result.mpreset) {
 		throw new Error("--default requires --mpreset <name>");
 	}
+	if (
+		result.mcpConfig !== undefined &&
+		(result.mode === "acp" || result.listModels !== undefined || result.export !== undefined)
+	) {
+		throw new CliParseError(
+			"--mcp-config is only supported in standalone interactive, tmux, print, text, or json modes.",
+		);
+	}
 
 	return result;
 }

package/src/cli/auth-gateway-cli.ts

@@ -2,7 +2,7 @@
  * `skc auth-gateway` command handlers.
  *
  * Boots a forward-proxy server that lets less-trusted clients (the macOS
- * usage widget, roboskc containers, …) make provider API calls without ever
+ * usage widget and containerized deployments) make provider API calls without ever
  * seeing the access token. The gateway is itself a broker client and
  * resolves credentials through the configured broker (via the same
  * `SKC_AUTH_BROKER_URL` / `auth.broker.url` precedence used elsewhere).
@@ -139,7 +139,7 @@ async function runServe(flags: AuthGatewayCommandArgs["flags"]): Promise<void> {
 	const gatewayToken = flags.noAuth ? null : await ensureToken();
 
 	// Build a broker-backed AuthStorage — same pattern as discoverAuthStorage()
-	// in sdk.ts. The gateway never touches local SQLite.
+	// in sdk/session.ts. The gateway never touches local SQLite.
 	const client = createBrokerClient(brokerConfig);
 	const initialSnapshot = await fetchBrokerSnapshot(client);
 	const store = new RemoteAuthCredentialStore({ client, initialSnapshot });

package/src/cli/config-cli.ts

@@ -5,7 +5,10 @@
  * Uses the settings schema as the source of truth for available settings.
  */
 
+import * as fs from "node:fs/promises";
+import type * as path from "node:path";
 import { APP_NAME, getAgentDir } from "@sayknow-cli/utils";
+import { YAML } from "bun";
 import chalk from "chalk";
 import {
 	getDefault,
@@ -25,7 +28,7 @@ import { initXdg } from "./commands/init-xdg";
 // Types
 // =============================================================================
 
-export type ConfigAction = "list" | "get" | "set" | "reset" | "path" | "init-xdg";
+export type ConfigAction = "list" | "get" | "set" | "reset" | "path" | "doctor" | "init-xdg";
 
 export interface ConfigCommandArgs {
 	action: ConfigAction;
@@ -111,7 +114,7 @@ function getSettingValues(def: CliSettingDef): readonly string[] | undefined {
 // Argument Parser
 // =============================================================================
 
-const VALID_ACTIONS: ConfigAction[] = ["list", "get", "set", "reset", "path", "init-xdg"];
+const VALID_ACTIONS: ConfigAction[] = ["list", "get", "set", "reset", "path", "doctor", "init-xdg"];
 
 /**
  * Parse config subcommand arguments.
@@ -299,6 +302,9 @@ export async function runConfigCommand(cmd: ConfigCommandArgs): Promise<void> {
 		case "path":
 			handlePath();
 			break;
+		case "doctor":
+			handleDoctor(cmd.flags);
+			break;
 		case "init-xdg":
 			await initXdg();
 			break;
@@ -429,7 +435,8 @@ async function handleReset(key: string | undefined, flags: { json?: boolean }):
 
 	const path = def.path as SettingPath;
 	const defaultValue = getDefault(path);
-	settings.set(path, defaultValue as SettingValue<typeof path>);
+	if (defaultValue === undefined) settings.unset(path);
+	else settings.set(path, defaultValue as SettingValue<typeof path>);
 
 	if (flags.json) {
 		console.log(JSON.stringify({ key: def.path, value: defaultValue }));
@@ -442,6 +449,70 @@ function handlePath(): void {
 	console.log(getAgentDir());
 }
 
+function handleDoctor(flags: { json?: boolean }): void {
+	const report = settings.getSchemaReport();
+	if (flags.json) {
+		console.log(JSON.stringify(report, null, 2));
+		return;
+	}
+	if (report.issues.length === 0) {
+		console.log(chalk.green("Settings schema is healthy."));
+		return;
+	}
+	for (const issue of report.issues) console.log(`${issue.kind}\t${issue.path}\t${issue.detail}`);
+}
+
+type ConfigDoctorReport = {
+	unknownKeys: string[];
+	invalidValues: Array<{ path: string; value: unknown }>;
+	legacyShapes: string[];
+};
+
+function flattenConfig(value: unknown, prefix = ""): Array<[string, unknown]> {
+	if (prefix && ALL_SETTING_PATHS.includes(prefix as SettingPath)) return [[prefix, value]];
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return prefix ? [[prefix, value]] : [];
+	return Object.entries(value).flatMap(([key, child]) => flattenConfig(child, prefix ? `${prefix}.${key}` : key));
+}
+
+function matchesSettingType(path: SettingPath, value: unknown): boolean {
+	const definition = SETTINGS_SCHEMA[path];
+	switch (definition.type) {
+		case "string":
+		case "enum":
+			return (
+				typeof value === "string" && (definition.type !== "enum" || getEnumValues(path)?.includes(value) === true)
+			);
+		case "number":
+			return typeof value === "number" && Number.isFinite(value);
+		case "boolean":
+			return typeof value === "boolean";
+		case "array":
+			return Array.isArray(value);
+		case "record":
+			return value !== null && typeof value === "object" && !Array.isArray(value);
+	}
+}
+
+export async function inspectConfigFile(configPath: string): Promise<ConfigDoctorReport> {
+	const report: ConfigDoctorReport = { unknownKeys: [], invalidValues: [], legacyShapes: [] };
+	try {
+		const raw = YAML.parse(await fs.readFile(configPath, "utf8"));
+		if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+			report.legacyShapes.push("config root is not a mapping");
+			return report;
+		}
+		for (const [settingPath, value] of flattenConfig(raw)) {
+			if (!ALL_SETTING_PATHS.includes(settingPath as SettingPath)) report.unknownKeys.push(settingPath);
+			else if (!matchesSettingType(settingPath as SettingPath, value))
+				report.invalidValues.push({ path: settingPath, value: redactConfigValue(settingPath, value) });
+		}
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT")
+			report.legacyShapes.push(`unable to parse config: ${String(error)}`);
+	}
+	return report;
+}
+
 // =============================================================================
 // Help
 // =============================================================================
@@ -454,8 +525,10 @@ ${chalk.bold("Commands:")}
   get <key>          Get a specific setting value
   set <key> <value>  Set a setting value
   reset <key>        Reset a setting to its default value
+  doctor             Report unknown, invalid, and pending settings migrations
   path               Print the config directory path
   init-xdg           Initialize XDG Base Directory structure
+  doctor             Report unknown, invalid, and legacy config entries
 
 ${chalk.bold("Options:")}
   --json             Output as JSON
@@ -471,6 +544,7 @@ ${chalk.bold("Examples:")}
   ${APP_NAME} config list --json
   ${APP_NAME} config get auth.broker.token --show-secrets
   ${APP_NAME} config init-xdg
+  ${APP_NAME} config doctor --json
 
 ${chalk.bold("Boolean Values:")}
   true, false, yes, no, on, off, 1, 0

package/src/cli/daemon-cli.ts

@@ -6,7 +6,7 @@
  */
 
 import { Settings } from "../config/settings";
-import { selectDaemonControllers } from "../daemon/builtin";
+import { BUILT_IN_DAEMON_KINDS, selectDaemonControllers } from "../daemon/builtin";
 import type {
 	BuiltInDaemonController,
 	DaemonKind,
@@ -20,11 +20,28 @@ import {
 	formatDaemonStatus,
 	resolveDaemonAction,
 } from "../daemon/operator-contract";
+import { runChatDaemonInternal } from "../sdk/bus/chat-daemon-cli";
 
 export type DaemonCliAction = "list" | "status" | "stop" | "reload";
+export type DaemonInternalCliAction = "discord-internal" | "slack-internal";
+export type DaemonCommandAction = DaemonCliAction | DaemonInternalCliAction;
+
+export class UnknownDaemonKindError extends Error {
+	constructor(
+		readonly kinds: readonly string[],
+		readonly knownKinds: readonly DaemonKind[],
+	) {
+		super(`Unknown daemon kind(s): ${kinds.join(", ")}. Known kinds: ${knownKinds.join(", ")}.`);
+		this.name = "UnknownDaemonKindError";
+	}
+}
+
+export function isDaemonInternalAction(action: DaemonCommandAction): action is DaemonInternalCliAction {
+	return action === "discord-internal" || action === "slack-internal";
+}
 
 export interface DaemonCommandArgs {
-	action: DaemonCliAction;
+	action: DaemonCommandAction;
 	kinds: DaemonKind[];
 	all: boolean;
 	json: boolean;
@@ -32,6 +49,9 @@ export interface DaemonCommandArgs {
 	gracefulTimeoutMs?: number;
 	killTimeoutMs?: number;
 	spawnIfStopped?: boolean;
+	smoke?: boolean;
+	ownerId?: string;
+	agentDir?: string;
 	/** Show runtime detail and the full roots list in human output. */
 	verbose?: boolean;
 }
@@ -41,14 +61,21 @@ export interface DaemonCommandDeps {
 	controllers?: BuiltInDaemonController[];
 }
 
-const KNOWN_KINDS: DaemonKind[] = ["telegram"];
+const INTERNAL_ACTIONS: DaemonInternalCliAction[] = ["discord-internal", "slack-internal"];
+const KNOWN_KINDS = BUILT_IN_DAEMON_KINDS;
 
 export function parseDaemonArgs(argv: string[]): DaemonCommandArgs | undefined {
 	if (argv.length === 0 || argv[0] !== "daemon") return undefined;
 	const rest = argv.slice(1);
-	const resolved = resolveDaemonAction(rest[0]);
-	const isActionToken = (DAEMON_ACTION_TOKENS as readonly string[]).includes(rest[0] ?? "");
-	const action = (resolved ?? "status") as DaemonCliAction;
+	const actionToken = rest[0];
+	const resolved = resolveDaemonAction(actionToken);
+	const action = (resolved ??
+		((INTERNAL_ACTIONS as readonly string[]).includes(actionToken ?? "")
+			? actionToken
+			: "status")) as DaemonCommandAction;
+	const isActionToken =
+		(DAEMON_ACTION_TOKENS as readonly string[]).includes(actionToken ?? "") ||
+		(INTERNAL_ACTIONS as readonly string[]).includes(actionToken ?? "");
 	const positional = isActionToken ? rest.slice(1) : rest;
 	const kinds: DaemonKind[] = [];
 	let all = false;
@@ -58,6 +85,9 @@ export function parseDaemonArgs(argv: string[]): DaemonCommandArgs | undefined {
 	let gracefulTimeoutMs: number | undefined;
 	let killTimeoutMs: number | undefined;
 	let spawnIfStopped: boolean | undefined;
+	let smoke = false;
+	let ownerId: string | undefined;
+	let agentDir: string | undefined;
 	for (let i = 0; i < positional.length; i++) {
 		const arg = positional[i];
 		if (arg === "--all") all = true;
@@ -65,21 +95,40 @@ export function parseDaemonArgs(argv: string[]): DaemonCommandArgs | undefined {
 		else if (arg === "--force") force = true;
 		else if (arg === "--verbose" || arg === "-v") verbose = true;
 		else if (arg === "--spawn-if-stopped") spawnIfStopped = true;
+		else if (arg === "--smoke") smoke = true;
+		else if (arg === "--owner-id") ownerId = positional[++i];
+		else if (arg === "--agent-dir") agentDir = positional[++i];
 		else if (arg === "--graceful-timeout-ms") gracefulTimeoutMs = Number.parseInt(positional[++i], 10);
 		else if (arg === "--kill-timeout-ms") killTimeoutMs = Number.parseInt(positional[++i], 10);
-		else if (!arg.startsWith("--") && (KNOWN_KINDS as string[]).includes(arg)) kinds.push(arg as DaemonKind);
+		else if (!arg.startsWith("--")) kinds.push(arg as DaemonKind);
 	}
-	return { action, kinds, all, json, force, verbose, gracefulTimeoutMs, killTimeoutMs, spawnIfStopped };
+	return {
+		action,
+		kinds,
+		all,
+		json,
+		force,
+		verbose,
+		gracefulTimeoutMs,
+		killTimeoutMs,
+		spawnIfStopped,
+		smoke,
+		ownerId,
+		agentDir,
+	};
 }
 export async function runDaemonCommand(cmd: DaemonCommandArgs, deps: DaemonCommandDeps = {}): Promise<void> {
-	const unknownKinds = cmd.kinds.filter(kind => !(KNOWN_KINDS as string[]).includes(kind));
-	if (unknownKinds.length > 0) {
-		process.stderr.write(
-			`Unknown daemon kind(s): ${unknownKinds.join(", ")}. Known kinds: ${KNOWN_KINDS.join(", ")}.\n`,
-		);
-		process.exitCode = 1;
+	if (isDaemonInternalAction(cmd.action)) {
+		const args = [
+			...(cmd.smoke ? ["--smoke"] : []),
+			...(cmd.ownerId ? ["--owner-id", cmd.ownerId] : []),
+			...(cmd.agentDir ? ["--agent-dir", cmd.agentDir] : []),
+		];
+		await runChatDaemonInternal(cmd.action === "discord-internal" ? "discord" : "slack", args);
 		return;
 	}
+	const unknownKinds = cmd.kinds.filter(kind => !(KNOWN_KINDS as readonly string[]).includes(kind));
+	if (unknownKinds.length > 0) throw new UnknownDaemonKindError(unknownKinds, KNOWN_KINDS);
 	const settings = deps.settings ?? (await Settings.init());
 	const controllers = deps.controllers ?? selectDaemonControllers(settings, cmd.kinds, cmd.all);
 

package/src/cli/launch-disposition.ts

@@ -0,0 +1,42 @@
+export type LaunchMode = "text" | "json" | "acp";
+
+export interface LaunchDisposition {
+	autoPrint: boolean;
+	isInteractive: boolean;
+	/** Set when an interactive launch is impossible (non-TTY stdin, nothing to run). */
+	nonInteractiveError?: string;
+}
+
+/**
+ * Decides between interactive, auto-print, and fail-fast launches.
+ *
+ * A non-TTY stdin means the TUI can never receive input, so an interactive
+ * launch would execute the initial prompt and then block in the event loop
+ * forever. Prepared command-line input degrades to print mode; without any
+ * input to run we fail fast instead of hanging. Explicit `--print` and
+ * `--mode` launches are left untouched.
+ */
+export function resolveLaunchDisposition(args: {
+	stdinIsTTY: boolean | undefined;
+	pipedInput: string | undefined;
+	hasPreparedInput: boolean;
+	print: boolean;
+	mode: LaunchMode | undefined;
+}): LaunchDisposition {
+	const explicitNonInteractive = args.print || args.mode !== undefined;
+	const hasPreparedInput = args.pipedInput !== undefined || args.hasPreparedInput;
+	const hasNonTtyStdin = args.stdinIsTTY !== true;
+	const autoPrint = !explicitNonInteractive && hasNonTtyStdin && hasPreparedInput;
+	const isInteractive = !explicitNonInteractive && !autoPrint;
+
+	if (isInteractive && args.stdinIsTTY !== true) {
+		return {
+			autoPrint: false,
+			isInteractive: false,
+			nonInteractiveError:
+				"stdin is not a TTY and no prompt or prepared input was provided; use -p/--print (or pass a prompt or @file) for non-interactive runs.",
+		};
+	}
+
+	return { autoPrint, isInteractive };
+}

package/src/cli/list-models.ts

@@ -191,7 +191,7 @@ export async function runListModelsCommand(options: RunListModelsOptions): Promi
 		process.stderr.write(`Failed to load extension: ${extPath}: ${error}\n`);
 	}
 
-	// Mirror sdk.ts: drain pending provider registrations into the registry.
+	// Mirror sdk/session.ts: drain pending provider registrations into the registry.
 	const activeSources = extensionsResult.extensions.map(extension => extension.path);
 	modelRegistry.syncExtensionSources(activeSources);
 	for (const sourceId of new Set(activeSources)) {