@cjhyy/code-shell-capability-coding 0.8.0

package/dist/cc-orchestrator/session-discovery.d.ts

@@ -0,0 +1,99 @@
+/** Encode a cwd to claude's project dir name: every non-[A-Za-z0-9] char → '-'.
+ *  Mirrors `~/.claude/projects/<encoded>` (verified against real layout). */
+export declare function encodeCwd(cwd: string): string;
+/** Session discovered from an external coding CLI. */
+export interface DiscoveredSession {
+    sessionId: string;
+    /** The cwd recorded by the external CLI for this session. Consumers must
+     *  open/resume the session with this path instead of assuming the currently
+     *  selected CodeShell project has the same cwd (DriveAgent worktrees often
+     *  do not). */
+    cwd: string;
+    firstMessage: string;
+    lastModified: number;
+    messageCount: number;
+}
+/** A session discovered globally from an external CLI's own storage, with the
+ *  file path so the Pet adapter can tail it. Shared by codex + claude paths. */
+export interface RecentExternalSession {
+    sessionId: string;
+    cwd: string;
+    file: string;
+    lastModified: number;
+    firstMessage: string;
+}
+/** One registered CodeShell project root and its effective visibility. */
+export interface ExternalSessionProjectRoot {
+    cwd: string;
+    enabled: boolean;
+}
+/**
+ * Source-level discovery scope. Registered roots use longest-ancestor matching;
+ * sessions outside every registered root follow includeUnregistered (the user
+ * global baseline).
+ */
+export interface ExternalSessionDiscoveryScope {
+    includeUnregistered: boolean;
+    projectRoots: readonly ExternalSessionProjectRoot[];
+}
+/** Resolve aliases such as a trailing slash before comparing project roots. */
+export declare function normalizeExternalSessionCwd(cwd: string): string;
+/** Pick the most specific registered ancestor for a session cwd. */
+export declare function externalSessionProjectRootFor(cwd: string, roots: readonly ExternalSessionProjectRoot[]): ExternalSessionProjectRoot | undefined;
+/** Apply a discovery scope to one real cwd. */
+export declare function externalSessionCwdEnabled(cwd: string, scope?: ExternalSessionDiscoveryScope): boolean;
+/**
+ * Cheap Claude-directory prefilter. Because encodeCwd is lossy, true only means
+ * "this directory may contain an enabled cwd". The real cwd identity is always
+ * checked before transcript content is read.
+ */
+export declare function claudeProjectDirEnabled(encodedProjectDir: string, scope?: ExternalSessionDiscoveryScope): boolean;
+/**
+ * Bound how many sessions a discovery scan deep-reads + returns. Without this,
+ * `discoverSessions` read EVERY `.jsonl` file fully (title + message count) on
+ * every list open — O(all history) work that makes the CC/Codex room list slow
+ * and unwieldy once a project accumulates sessions. The default surfaces only
+ * the recent, useful slice; the UI fetches older ones on demand by passing a
+ * larger `limit` (or `sinceMs: 0`).
+ */
+export interface DiscoverOptions {
+    /** Max sessions to return (after the recency filter), newest first.
+     *  undefined or <= 0 = no cap. */
+    limit?: number;
+    /** Only include sessions modified within this many ms of `now`.
+     *  undefined or <= 0 = no window. */
+    sinceMs?: number;
+    /** Injectable clock for tests. Defaults to Date.now(). */
+    now?: number;
+}
+/** Default room-list window: last 2 weeks AND at most 20 — the intersection. */
+export declare const DEFAULT_DISCOVER_LIMIT = 20;
+export declare const DEFAULT_DISCOVER_SINCE_MS: number;
+/**
+ * Apply the recency window + limit to mtime-sorted stats, returning the slice to
+ * deep-read. Shared by the claude + codex discovery paths so they bound work
+ * identically. `total` (caller-side) lets the UI show a "load more" affordance.
+ */
+export declare function selectRecentStats<T extends {
+    mtimeMs: number;
+}>(stats: T[], opts?: DiscoverOptions): T[];
+/** List claude sessions for `cwd`. `claudeHome` defaults to ~/.claude (override
+ *  for tests). Read-only, on-demand scan; no index. Stats every file cheaply,
+ *  then deep-reads (title + count) ONLY the recent slice (opts) so an old,
+ *  large history doesn't get fully read on every list open. */
+export declare function discoverSessions(cwd: string, claudeHome?: string, opts?: DiscoverOptions): DiscoveredSession[];
+export interface ClaudeSessionDiscoveryDiagnostics {
+    /** Called immediately before the 1 MiB title/content prefix is read. */
+    onContentRead?: (file: string) => void;
+}
+/**
+ * Discover ALL recent Claude Code sessions across every project dir. Claude
+ * encodes cwd into the dir name lossily (encodeCwd), so the real cwd comes from
+ * the session file's first-line `cwd` field. After the stat/recency pass, read a
+ * small identity prefix first and apply scope. Only enabled identities receive
+ * the larger bounded content read used to find the card title.
+ */
+export declare function discoverRecentClaudeSessions(opts?: DiscoverOptions, claudeHome?: string, scope?: ExternalSessionDiscoveryScope, diagnostics?: ClaudeSessionDiscoveryDiagnostics): RecentExternalSession[];
+/** Count of all session files for `cwd`, cheaply (stat only). Lets the UI know
+ *  whether a bounded `discoverSessions` left older sessions unshown. */
+export declare function countSessions(cwd: string, claudeHome?: string): number;

package/dist/cc-orchestrator/session-discovery.js

@@ -0,0 +1,295 @@
+import { readdirSync, readFileSync, statSync, existsSync, openSync, readSync, closeSync, } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { homedir } from "node:os";
+/** Encode a cwd to claude's project dir name: every non-[A-Za-z0-9] char → '-'.
+ *  Mirrors `~/.claude/projects/<encoded>` (verified against real layout). */
+export function encodeCwd(cwd) {
+    return cwd.replace(/[^A-Za-z0-9]/g, "-");
+}
+/** Resolve aliases such as a trailing slash before comparing project roots. */
+export function normalizeExternalSessionCwd(cwd) {
+    return resolve(cwd);
+}
+function isWithinRoot(cwd, root) {
+    const child = relative(root, cwd);
+    return child === "" || (!child.startsWith("..") && !isAbsolute(child));
+}
+/** Pick the most specific registered ancestor for a session cwd. */
+export function externalSessionProjectRootFor(cwd, roots) {
+    const normalizedCwd = normalizeExternalSessionCwd(cwd);
+    let best;
+    for (const candidate of roots) {
+        const normalizedRoot = normalizeExternalSessionCwd(candidate.cwd);
+        if (!isWithinRoot(normalizedCwd, normalizedRoot))
+            continue;
+        if (!best || normalizedRoot.length > normalizeExternalSessionCwd(best.cwd).length) {
+            best = { ...candidate, cwd: normalizedRoot };
+        }
+    }
+    return best;
+}
+/** Apply a discovery scope to one real cwd. */
+export function externalSessionCwdEnabled(cwd, scope) {
+    if (!scope)
+        return true;
+    return (externalSessionProjectRootFor(cwd, scope.projectRoots)?.enabled ?? scope.includeUnregistered);
+}
+/**
+ * Cheap Claude-directory prefilter. Because encodeCwd is lossy, true only means
+ * "this directory may contain an enabled cwd". The real cwd identity is always
+ * checked before transcript content is read.
+ */
+export function claudeProjectDirEnabled(encodedProjectDir, scope) {
+    if (!scope)
+        return true;
+    // With an enabled unregistered baseline, an encoded name can never prove a
+    // directory is disabled: `/work/repo-other` looks like a descendant of
+    // `/work/repo`, and `/foo-bar` collides exactly with `/foo/bar`. Probe only
+    // the small identity prefix and decide from the real cwd later.
+    if (scope.includeUnregistered)
+        return true;
+    return scope.projectRoots.some((candidate) => {
+        if (!candidate.enabled)
+            return false;
+        const normalizedRoot = normalizeExternalSessionCwd(candidate.cwd);
+        const exact = encodeCwd(normalizedRoot);
+        const descendantPrefix = encodeCwd(normalizedRoot.endsWith(sep) ? normalizedRoot : `${normalizedRoot}${sep}`);
+        return encodedProjectDir === exact || encodedProjectDir.startsWith(descendantPrefix);
+    });
+}
+/** Default room-list window: last 2 weeks AND at most 20 — the intersection. */
+export const DEFAULT_DISCOVER_LIMIT = 20;
+export const DEFAULT_DISCOVER_SINCE_MS = 14 * 24 * 60 * 60 * 1000;
+function claudeProjectsDir(claudeHome) {
+    return join(claudeHome, "projects");
+}
+/** Extract first *real* user message text, skipping caveat/command noise. */
+function firstUserMessage(lines) {
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        let d;
+        try {
+            d = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (d.type !== "user")
+            continue;
+        const c = d.message?.content;
+        const text = typeof c === "string"
+            ? c
+            : Array.isArray(c)
+                ? c.map((p) => (typeof p?.text === "string" ? p.text : "")).join("")
+                : "";
+        const t = text.trim();
+        if (!t)
+            continue;
+        if (t.startsWith("<local-command-caveat>") || t.startsWith("<command-name>"))
+            continue;
+        return t.slice(0, 200);
+    }
+    return "";
+}
+function countUserMessages(lines) {
+    let n = 0;
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            if (JSON.parse(line).type === "user")
+                n++;
+        }
+        catch {
+            /* skip */
+        }
+    }
+    return n;
+}
+/** Cheap (sessionId, mtime) pairs for every session file — stat only, no read. */
+function listSessionStats(dir) {
+    const stats = [];
+    for (const name of readdirSync(dir)) {
+        if (!name.endsWith(".jsonl"))
+            continue;
+        const file = join(dir, name);
+        let st;
+        try {
+            st = statSync(file);
+        }
+        catch {
+            continue;
+        }
+        stats.push({ sessionId: name.replace(/\.jsonl$/, ""), file, mtimeMs: st.mtimeMs });
+    }
+    return stats;
+}
+/**
+ * Apply the recency window + limit to mtime-sorted stats, returning the slice to
+ * deep-read. Shared by the claude + codex discovery paths so they bound work
+ * identically. `total` (caller-side) lets the UI show a "load more" affordance.
+ */
+export function selectRecentStats(stats, opts = {}) {
+    const now = opts.now ?? Date.now();
+    let sel = stats.slice().sort((a, b) => b.mtimeMs - a.mtimeMs);
+    if (opts.sinceMs && opts.sinceMs > 0) {
+        const cutoff = now - opts.sinceMs;
+        sel = sel.filter((s) => s.mtimeMs >= cutoff);
+    }
+    if (opts.limit && opts.limit > 0)
+        sel = sel.slice(0, opts.limit);
+    return sel;
+}
+/** List claude sessions for `cwd`. `claudeHome` defaults to ~/.claude (override
+ *  for tests). Read-only, on-demand scan; no index. Stats every file cheaply,
+ *  then deep-reads (title + count) ONLY the recent slice (opts) so an old,
+ *  large history doesn't get fully read on every list open. */
+export function discoverSessions(cwd, claudeHome = join(homedir(), ".claude"), opts = {}) {
+    const dir = join(claudeProjectsDir(claudeHome), encodeCwd(cwd));
+    if (!existsSync(dir))
+        return [];
+    const selected = selectRecentStats(listSessionStats(dir), opts);
+    const out = [];
+    for (const s of selected) {
+        let lines;
+        try {
+            lines = readFileSync(s.file, "utf-8").split("\n");
+        }
+        catch {
+            continue;
+        }
+        out.push({
+            sessionId: s.sessionId,
+            cwd,
+            firstMessage: firstUserMessage(lines),
+            lastModified: s.mtimeMs,
+            messageCount: countUserMessages(lines),
+        });
+    }
+    return out;
+}
+/** Read up to maxBytes of a file as UTF-8 (may span many lines), without
+ *  loading the whole transcript. Newlines are preserved so callers can split. */
+function readBoundedPrefix(file, maxBytes) {
+    const fd = openSync(file, "r");
+    try {
+        const buf = Buffer.alloc(maxBytes);
+        const n = readSync(fd, buf, 0, maxBytes, 0);
+        return buf.toString("utf-8", 0, n);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/**
+ * Read only enough of the first line to recover Claude's top-level cwd
+ * identity. The field precedes message content in Claude's records; if a
+ * nonstandard record puts it after a large payload, fail closed instead of
+ * reading transcript content merely to classify visibility.
+ */
+function readSessionIdentityCwd(file, maxBytes = 4 * 1024) {
+    const fd = openSync(file, "r");
+    try {
+        const buffer = Buffer.alloc(maxBytes);
+        let total = 0;
+        while (total < maxBytes) {
+            const read = readSync(fd, buffer, total, Math.min(256, maxBytes - total), total);
+            if (read === 0)
+                return undefined;
+            total += read;
+            const text = buffer.subarray(0, total).toString("utf-8");
+            const newline = text.indexOf("\n");
+            const firstLine = newline >= 0 ? text.slice(0, newline) : text;
+            const cwdIndex = firstLine.indexOf('"cwd"');
+            const messageIndex = firstLine.indexOf('"message"');
+            if (messageIndex >= 0 && (cwdIndex < 0 || cwdIndex > messageIndex))
+                return undefined;
+            if (cwdIndex < 0) {
+                if (newline >= 0)
+                    return undefined;
+                continue;
+            }
+            const match = firstLine.slice(cwdIndex).match(/^"cwd"\s*:\s*("(?:\\.|[^"\\])*")/);
+            if (!match)
+                continue;
+            try {
+                const cwd = JSON.parse(match[1]);
+                return typeof cwd === "string" ? cwd : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/**
+ * Discover ALL recent Claude Code sessions across every project dir. Claude
+ * encodes cwd into the dir name lossily (encodeCwd), so the real cwd comes from
+ * the session file's first-line `cwd` field. After the stat/recency pass, read a
+ * small identity prefix first and apply scope. Only enabled identities receive
+ * the larger bounded content read used to find the card title.
+ */
+export function discoverRecentClaudeSessions(opts = {}, claudeHome = join(homedir(), ".claude"), scope, diagnostics) {
+    const projects = claudeProjectsDir(claudeHome);
+    if (!existsSync(projects))
+        return [];
+    const stats = [];
+    for (const projectDir of readdirSync(projects)) {
+        // Skip directories that cannot contain an enabled root. Ambiguous lossy
+        // names proceed only to the small per-file identity read below.
+        if (!claudeProjectDirEnabled(projectDir, scope))
+            continue;
+        const dir = join(projects, projectDir);
+        let dirStat;
+        try {
+            dirStat = statSync(dir);
+        }
+        catch {
+            continue;
+        }
+        if (!dirStat.isDirectory())
+            continue;
+        for (const entry of listSessionStats(dir)) {
+            stats.push({ file: entry.file, sessionId: entry.sessionId, mtimeMs: entry.mtimeMs });
+        }
+    }
+    const windowed = selectRecentStats(stats, { sinceMs: opts.sinceMs, now: opts.now });
+    const limit = opts.limit && opts.limit > 0 ? opts.limit : Infinity;
+    const out = [];
+    for (const s of windowed) {
+        if (out.length >= limit)
+            break;
+        let cwd;
+        try {
+            cwd = readSessionIdentityCwd(s.file);
+        }
+        catch {
+            continue;
+        }
+        if (!cwd || !externalSessionCwdEnabled(cwd, scope))
+            continue;
+        let firstMessage = "";
+        try {
+            diagnostics?.onContentRead?.(s.file);
+            firstMessage = firstUserMessage(readBoundedPrefix(s.file, 1 << 20).split("\n"));
+        }
+        catch {
+            continue;
+        }
+        out.push({ sessionId: s.sessionId, cwd, file: s.file, lastModified: s.mtimeMs, firstMessage });
+    }
+    return out;
+}
+/** Count of all session files for `cwd`, cheaply (stat only). Lets the UI know
+ *  whether a bounded `discoverSessions` left older sessions unshown. */
+export function countSessions(cwd, claudeHome = join(homedir(), ".claude")) {
+    const dir = join(claudeProjectsDir(claudeHome), encodeCwd(cwd));
+    if (!existsSync(dir))
+        return 0;
+    return listSessionStats(dir).length;
+}

package/dist/cc-orchestrator/session-history.d.ts

@@ -0,0 +1,55 @@
+/** Normalized external coding-agent history message. */
+export interface HistoryMessage {
+    role: "user" | "assistant";
+    text: string;
+    /** `summary` is a lossy one-field preview; `args` is the full tool_use input
+     *  (e.g. a sub-agent's `prompt`) so a replayed tool card can show the real
+     *  parameters, not just the whitelisted field. */
+    tools?: {
+        name: string;
+        summary: string;
+        args?: Record<string, unknown>;
+    }[];
+    ts?: number;
+}
+/** One render-relevant event parsed from an appended external-CLI transcript
+ * line. Kept CLI-neutral so the desktop room follower can feed Claude Code and
+ * Codex through the same RoomManager push path. */
+export type SessionTailEvent = {
+    type: "user";
+    text: string;
+} | {
+    type: "assistant";
+    text: string;
+} | {
+    type: "tool";
+    id?: string;
+    name: string;
+    summary: string;
+    args?: Record<string, unknown>;
+} | {
+    type: "tool_result";
+    id?: string;
+    result: string;
+    isError: boolean;
+} | {
+    type: "turn_end";
+    reason: string;
+};
+/** Parse a bounded/raw Claude Code transcript snapshot. Exported so a live
+ * follower can take its initial snapshot and EOF cursor from the same read,
+ * eliminating the snapshot→subscribe race. */
+export declare function parseRecentHistory(raw: string, limit: number): {
+    messages: HistoryMessage[];
+    hasMore: boolean;
+    totalCount: number;
+};
+/** Parse one newly-appended Claude Code transcript JSONL line into the compact
+ * event vocabulary consumed by the desktop room follower. */
+export declare function parseClaudeTranscriptLine(line: string): SessionTailEvent[];
+/** Read the last `limit` user/assistant messages from a claude session jsonl. */
+export declare function readRecentHistory(cwd: string, sessionId: string, limit: number, claudeHome?: string): {
+    messages: HistoryMessage[];
+    hasMore: boolean;
+    totalCount: number;
+};

package/dist/cc-orchestrator/session-history.js

@@ -0,0 +1,150 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { encodeCwd } from "./session-discovery.js";
+const NOISE = ["<local-command-caveat>", "<command-name>"];
+function textOf(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content))
+        return content.map((p) => (typeof p?.text === "string" ? p.text : "")).join("");
+    return "";
+}
+function toolsOf(content) {
+    if (!Array.isArray(content))
+        return [];
+    const out = [];
+    for (const p of content) {
+        if (p?.type === "tool_use") {
+            const inp = p.input ?? {};
+            const summary = inp.command ?? inp.file_path ?? inp.path ?? inp.url ?? inp.pattern ?? inp.query ?? "";
+            const args = inp && typeof inp === "object" && Object.keys(inp).length > 0 ? inp : undefined;
+            out.push({
+                name: typeof p.name === "string" ? p.name : "tool",
+                summary: String(summary).slice(0, 120),
+                args,
+            });
+        }
+    }
+    return out;
+}
+function toolResultText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => typeof part === "string" ? part : typeof part?.text === "string" ? part.text : "")
+        .join("");
+}
+/** Parse a bounded/raw Claude Code transcript snapshot. Exported so a live
+ * follower can take its initial snapshot and EOF cursor from the same read,
+ * eliminating the snapshot→subscribe race. */
+export function parseRecentHistory(raw, limit) {
+    const all = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        let d;
+        try {
+            d = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (d.type === "user") {
+            const t = textOf(d.message?.content).trim();
+            if (!t || NOISE.some((n) => t.startsWith(n)))
+                continue;
+            all.push({ role: "user", text: t });
+        }
+        else if (d.type === "assistant") {
+            const t = textOf(d.message?.content).trim();
+            const tools = toolsOf(d.message?.content);
+            if (!t && tools.length === 0)
+                continue;
+            all.push({ role: "assistant", text: t, tools: tools.length ? tools : undefined });
+        }
+    }
+    const lim = limit > 0 ? limit : 20;
+    const start = Math.max(0, all.length - lim);
+    return { messages: all.slice(start), hasMore: start > 0, totalCount: all.length };
+}
+/** Parse one newly-appended Claude Code transcript JSONL line into the compact
+ * event vocabulary consumed by the desktop room follower. */
+export function parseClaudeTranscriptLine(line) {
+    let d;
+    try {
+        d = JSON.parse(line);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    if (d.type === "user") {
+        const content = d.message?.content;
+        if (Array.isArray(content)) {
+            for (const part of content) {
+                if (part?.type !== "tool_result")
+                    continue;
+                out.push({
+                    type: "tool_result",
+                    id: typeof part.tool_use_id === "string" ? part.tool_use_id : undefined,
+                    result: toolResultText(part.content).slice(0, 4000),
+                    isError: Boolean(part.is_error),
+                });
+            }
+        }
+        const text = textOf(content).trim();
+        if (text && !NOISE.some((noise) => text.startsWith(noise))) {
+            out.unshift({ type: "user", text });
+        }
+        return out;
+    }
+    if (d.type === "assistant" && Array.isArray(d.message?.content)) {
+        for (const part of d.message.content) {
+            if (part?.type === "text" && typeof part.text === "string" && part.text) {
+                out.push({ type: "assistant", text: part.text });
+            }
+            else if (part?.type === "tool_use") {
+                const input = part.input && typeof part.input === "object"
+                    ? part.input
+                    : undefined;
+                out.push({
+                    type: "tool",
+                    id: typeof part.id === "string" ? part.id : undefined,
+                    name: typeof part.name === "string" ? part.name : "tool",
+                    summary: toolsOf([part])[0]?.summary ?? "",
+                    args: input,
+                });
+            }
+        }
+        if (d.message.stop_reason === "end_turn") {
+            out.push({ type: "turn_end", reason: "completed" });
+        }
+        return out;
+    }
+    if (d.type === "result") {
+        return [
+            {
+                type: "turn_end",
+                reason: typeof d.subtype === "string" ? d.subtype : "completed",
+            },
+        ];
+    }
+    return [];
+}
+/** Read the last `limit` user/assistant messages from a claude session jsonl. */
+export function readRecentHistory(cwd, sessionId, limit, claudeHome = join(homedir(), ".claude")) {
+    const file = join(claudeHome, "projects", encodeCwd(cwd), `${sessionId}.jsonl`);
+    if (!existsSync(file))
+        return { messages: [], hasMore: false, totalCount: 0 };
+    let raw;
+    try {
+        raw = readFileSync(file, "utf-8");
+    }
+    catch {
+        return { messages: [], hasMore: false, totalCount: 0 };
+    }
+    return parseRecentHistory(raw, limit);
+}

package/dist/external-agents/config.d.ts

@@ -0,0 +1,3 @@
+import type { ExternalAgentsSettings, ResolvedExternalAgentsConfig } from "./types.js";
+/** Resolve coding CLI defaults without involving the agent kernel. */
+export declare function resolveExternalAgentConfig(settings: ExternalAgentsSettings | undefined): ResolvedExternalAgentsConfig;

package/dist/external-agents/config.js

@@ -0,0 +1,16 @@
+/** Resolve coding CLI defaults without involving the agent kernel. */
+export function resolveExternalAgentConfig(settings) {
+    return {
+        claudeCode: {
+            command: settings?.claudeCode?.command ?? "claude",
+            defaultMode: settings?.claudeCode?.defaultMode ?? "safe",
+            dangerousArgs: settings?.claudeCode?.dangerousArgs ?? [],
+            trustedWorkspaces: settings?.claudeCode?.trustedWorkspaces ?? [],
+            autoStartInTrustedWorkspaces: settings?.claudeCode?.autoStartInTrustedWorkspaces ?? false,
+        },
+        codex: {
+            command: settings?.codex?.command ?? "codex",
+            args: settings?.codex?.args ?? [],
+        },
+    };
+}

package/dist/external-agents/types.d.ts

@@ -0,0 +1,32 @@
+/** Permission profile for an external coding agent. */
+export type ExternalAgentMode = "safe" | "dangerous";
+export interface ClaudeCodeSettings {
+    command?: string;
+    defaultMode?: ExternalAgentMode;
+    dangerousArgs?: string[];
+    trustedWorkspaces?: string[];
+    autoStartInTrustedWorkspaces?: boolean;
+}
+export interface CodexSettings {
+    command?: string;
+    args?: string[];
+}
+export interface ExternalAgentsSettings {
+    claudeCode?: ClaudeCodeSettings;
+    codex?: CodexSettings;
+}
+export interface ResolvedClaudeCodeSettings {
+    command: string;
+    defaultMode: ExternalAgentMode;
+    dangerousArgs: string[];
+    trustedWorkspaces: string[];
+    autoStartInTrustedWorkspaces: boolean;
+}
+export interface ResolvedCodexSettings {
+    command: string;
+    args: string[];
+}
+export interface ResolvedExternalAgentsConfig {
+    claudeCode: ResolvedClaudeCodeSettings;
+    codex: ResolvedCodexSettings;
+}

package/dist/external-agents/types.js

@@ -0,0 +1 @@
+export {};