sidekick-shared 0.19.3 → 0.21.0

package/dist/codexProfiles.js

@@ -37,6 +37,8 @@ exports.getSystemCodexHome = getSystemCodexHome;
 exports.getCodexMonitoringHomes = getCodexMonitoringHomes;
 exports.getCodexProfilesDir = getCodexProfilesDir;
 exports.getCodexProfileHome = getCodexProfileHome;
+exports.readCodexAccountMetadata = readCodexAccountMetadata;
+exports.isCodexProfileAuthenticated = isCodexProfileAuthenticated;
 exports.listCodexAccounts = listCodexAccounts;
 exports.getActiveCodexAccount = getActiveCodexAccount;
 exports.resolveSidekickCodexHome = resolveSidekickCodexHome;
@@ -378,7 +380,7 @@ function prepareCodexAccount(label) {
         needsLogin: true,
     };
 }
-function finalizeCodexAccount(profileId) {
+function finalizeCodexAccount(profileId, opts = {}) {
     const pending = readPendingProfile(profileId);
     if (!pending) {
         return { success: false, error: `Codex profile ${profileId} was not prepared.` };
@@ -397,6 +399,9 @@ function finalizeCodexAccount(profileId) {
         metadata,
     };
     (0, accountRegistry_1.upsertSavedAccountProfile)(profile);
+    if (opts.activate === false) {
+        return { success: true };
+    }
     const hasCredentialFiles = fs.existsSync(path.join(codexHome, 'auth.json')) ||
         fs.existsSync(path.join(codexHome, '.credentials.json'));
     if (!hasCredentialFiles) {

package/dist/credentialIO.d.ts

@@ -8,6 +8,7 @@
  * Both accounts.ts and credentials.ts consume this module so that all
  * credential access is platform-correct in one place.
  */
+export declare const KEYCHAIN_SERVICE = "Claude Code-credentials";
 /**
  * Read the active Claude Code credentials as a parsed object.
  *
@@ -16,7 +17,7 @@
  *
  * Returns `null` when credentials are absent or unreadable.
  */
-export declare function readActiveCredentials(): unknown;
+export declare function readActiveCredentials(configDir?: string): unknown;
 /**
  * Write credentials to the active Claude Code credential store.
  *
@@ -25,4 +26,4 @@ export declare function readActiveCredentials(): unknown;
  *
  * Throws on failure.
  */
-export declare function writeActiveCredentials(credentials: unknown): void;
+export declare function writeActiveCredentials(credentials: unknown, configDir?: string): void;

package/dist/credentialIO.js

@@ -43,15 +43,17 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEYCHAIN_SERVICE = void 0;
 exports.readActiveCredentials = readActiveCredentials;
 exports.writeActiveCredentials = writeActiveCredentials;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const child_process_1 = require("child_process");
-const KEYCHAIN_SERVICE = 'Claude Code-credentials';
-function getCredentialsFilePath() {
-    return path.join(os.homedir(), '.claude', '.credentials.json');
+const claudeProfiles_1 = require("./claudeProfiles");
+exports.KEYCHAIN_SERVICE = 'Claude Code-credentials';
+function getCredentialsFilePath(configDir) {
+    return path.join(configDir ?? path.join(os.homedir(), '.claude'), '.credentials.json');
 }
 /**
  * Read the active Claude Code credentials as a parsed object.
@@ -61,11 +63,11 @@ function getCredentialsFilePath() {
  *
  * Returns `null` when credentials are absent or unreadable.
  */
-function readActiveCredentials() {
+function readActiveCredentials(configDir) {
     if (process.platform === 'darwin') {
         try {
             const raw = (0, child_process_1.execFileSync)('security', [
-                'find-generic-password', '-s', KEYCHAIN_SERVICE, '-w',
+                'find-generic-password', '-s', (0, claudeProfiles_1.claudeKeychainService)(configDir), '-w',
             ], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
             return JSON.parse(raw.trim());
         }
@@ -75,7 +77,7 @@ function readActiveCredentials() {
     }
     // Linux / WSL / Windows — file-based
     try {
-        return JSON.parse(fs.readFileSync(getCredentialsFilePath(), 'utf8'));
+        return JSON.parse(fs.readFileSync(getCredentialsFilePath(configDir), 'utf8'));
     }
     catch {
         return null;
@@ -89,20 +91,20 @@ function readActiveCredentials() {
  *
  * Throws on failure.
  */
-function writeActiveCredentials(credentials) {
+function writeActiveCredentials(credentials, configDir) {
     const json = JSON.stringify(credentials);
     JSON.parse(json); // validate round-trip
     if (process.platform === 'darwin') {
         (0, child_process_1.execFileSync)('security', [
             'add-generic-password', '-U',
-            '-s', KEYCHAIN_SERVICE,
+            '-s', (0, claudeProfiles_1.claudeKeychainService)(configDir),
             '-a', process.env.USER || 'user',
             '-w', json,
         ], { stdio: ['pipe', 'pipe', 'pipe'] });
         return;
     }
     // Linux / WSL / Windows — file-based
-    const credPath = getCredentialsFilePath();
+    const credPath = getCredentialsFilePath(configDir);
     const tmp = credPath + '.tmp';
     fs.writeFileSync(tmp, json, { encoding: 'utf8', mode: 0o600 });
     fs.renameSync(tmp, credPath);

package/dist/ensureDefaultAccounts.js

@@ -96,6 +96,12 @@ function ensureDefaultCodexAccount(options) {
 async function ensureDefaultAccounts(options) {
     const claude = await ensureDefaultClaudeAccount(options);
     const codex = ensureDefaultCodexAccount(options);
+    try {
+        (0, accounts_1.reconcileClaudeAuthState)();
+    }
+    catch (error) {
+        logFailure(options, 'Claude auth reconciliation failed.', error);
+    }
     try {
         (0, codexProfiles_1.reconcileCodexAuthState)();
     }

package/dist/extractors/gatherAssets.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Aggregate actionable assets for exactly one working directory.
+ *
+ * Portions adapted from `trawl` by Juan Fourie (B33pBeeps), MIT licensed:
+ * https://github.com/B33pBeeps/trawl
+ *
+ * @module extractors/gatherAssets
+ */
+import { type AssetAgent, type ExtractedAssets, type ExtractedAssetType } from './sessionAssets';
+export type { AssetAgent } from './sessionAssets';
+export interface GatherAssetsOptions {
+    cwd?: string;
+    agents?: AssetAgent[];
+    sessionsPerAgent?: number;
+    caps?: Partial<Record<ExtractedAssetType, number>>;
+}
+export interface GatherAssetsResult extends ExtractedAssets {
+    inChat: boolean;
+}
+export declare function gatherAssetsForCwd(options?: GatherAssetsOptions): GatherAssetsResult;

package/dist/extractors/gatherAssets.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Aggregate actionable assets for exactly one working directory.
+ *
+ * Portions adapted from `trawl` by Juan Fourie (B33pBeeps), MIT licensed:
+ * https://github.com/B33pBeeps/trawl
+ *
+ * @module extractors/gatherAssets
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gatherAssetsForCwd = gatherAssetsForCwd;
+const node_path_1 = require("node:path");
+const claudeAssets_1 = require("./sources/claudeAssets");
+const codexAssets_1 = require("./sources/codexAssets");
+const sessionAssets_1 = require("./sessionAssets");
+const ALL_AGENTS = ['claude', 'codex'];
+function gatherAssetsForCwd(options = {}) {
+    const cwd = (0, node_path_1.resolve)(options.cwd || process.cwd());
+    const sessionLimit = options.sessionsPerAgent ?? 3;
+    const agents = options.agents ?? ALL_AGENTS;
+    const caps = { ...sessionAssets_1.DEFAULT_CAPS, ...(options.caps || {}) };
+    const sources = [];
+    if (agents.includes('claude'))
+        sources.push((0, claudeAssets_1.readClaudeAssets)(cwd, sessionLimit));
+    if (agents.includes('codex'))
+        sources.push((0, codexAssets_1.readCodexAssets)(cwd, sessionLimit));
+    const merge = (key, cap) => (0, sessionAssets_1.capped)((0, sessionAssets_1.dedupeAssets)(sources.flatMap((source) => source[key]).sort(sessionAssets_1.byTimestampDesc)), cap);
+    return {
+        urls: merge('urls', caps.url),
+        paths: merge('paths', caps.path),
+        commands: merge('commands', caps.command),
+        plans: (0, sessionAssets_1.capped)((0, sessionAssets_1.dedupePlansByTitle)(sources.flatMap((source) => source.plans).sort(sessionAssets_1.byTimestampDesc)), caps.plan),
+        inChat: sources.some((source) => source.hadSession),
+    };
+}

package/dist/extractors/sessionAssets.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Extract actionable assets from agent session transcript text.
+ *
+ * Portions adapted from `trawl` by Juan Fourie (B33pBeeps), MIT licensed:
+ * https://github.com/B33pBeeps/trawl
+ *
+ * @module extractors/sessionAssets
+ */
+export type ExtractedAssetType = 'url' | 'path' | 'command' | 'plan';
+export type AssetAgent = 'claude' | 'codex';
+export interface ExtractedAssetProvenance {
+    agent?: AssetAgent;
+    sessionPath?: string;
+    source?: string;
+}
+export interface ExtractedAsset extends ExtractedAssetProvenance {
+    type: ExtractedAssetType;
+    text: string;
+    display: string;
+    timestamp?: string;
+}
+export interface ExtractedAssets {
+    urls: ExtractedAsset[];
+    paths: ExtractedAsset[];
+    commands: ExtractedAsset[];
+    plans: ExtractedAsset[];
+}
+export interface SourceAssets extends ExtractedAssets {
+    hadSession: boolean;
+}
+export declare const DEFAULT_CAPS: Record<ExtractedAssetType, number>;
+export declare function extractUrls(text: unknown): string[];
+export declare function extractFilePaths(text: unknown, cwd?: string): Array<{
+    file: string;
+    line?: number;
+}>;
+export declare function extractCommands(text: unknown): string[];
+export declare function urlAsset(url: string, timestamp?: string, provenance?: ExtractedAssetProvenance): ExtractedAsset;
+export declare function commandAsset(command: string, timestamp?: string, provenance?: ExtractedAssetProvenance): ExtractedAsset;
+export declare function pathAsset(path: {
+    file: string;
+    line?: number;
+}, timestamp?: string, provenance?: ExtractedAssetProvenance): ExtractedAsset;
+export declare function planAsset(markdown: string, timestamp?: string, provenance?: ExtractedAssetProvenance): ExtractedAsset;
+export declare function flat(value: string): string;
+export declare function planTitle(markdown: string): string;
+export declare function isExistingFile(filePath: string): boolean;
+export declare function readPlanFile(filePath: string | undefined): string | undefined;
+export declare function byTimestampDesc(a: ExtractedAsset, b: ExtractedAsset): number;
+export declare function dedupeAssets(assets: ExtractedAsset[]): ExtractedAsset[];
+export declare function dedupePlansByTitle(plans: ExtractedAsset[]): ExtractedAsset[];
+export declare function capped(assets: ExtractedAsset[], cap: number): ExtractedAsset[];

package/dist/extractors/sessionAssets.js

@@ -0,0 +1,219 @@
+"use strict";
+/**
+ * Extract actionable assets from agent session transcript text.
+ *
+ * Portions adapted from `trawl` by Juan Fourie (B33pBeeps), MIT licensed:
+ * https://github.com/B33pBeeps/trawl
+ *
+ * @module extractors/sessionAssets
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CAPS = void 0;
+exports.extractUrls = extractUrls;
+exports.extractFilePaths = extractFilePaths;
+exports.extractCommands = extractCommands;
+exports.urlAsset = urlAsset;
+exports.commandAsset = commandAsset;
+exports.pathAsset = pathAsset;
+exports.planAsset = planAsset;
+exports.flat = flat;
+exports.planTitle = planTitle;
+exports.isExistingFile = isExistingFile;
+exports.readPlanFile = readPlanFile;
+exports.byTimestampDesc = byTimestampDesc;
+exports.dedupeAssets = dedupeAssets;
+exports.dedupePlansByTitle = dedupePlansByTitle;
+exports.capped = capped;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const node_path_1 = require("node:path");
+const URL_RE = /(?:https?|file):\/\/[^\s"'<>)\]`\\]+/g;
+const PATH_RE = /(?:~|\.{0,2}\/)?[A-Za-z0-9_@.-]*(?:\/[A-Za-z0-9_@.-]+)+(?::\d+){0,2}|[A-Za-z0-9_@-]+\.[A-Za-z0-9]{1,8}(?::\d+){0,2}/g;
+const SHELL_TAGS = new Set(['sh', 'bash', 'shell', 'zsh', 'console', 'shellscript', 'shell-session']);
+exports.DEFAULT_CAPS = {
+    command: 60,
+    path: 60,
+    url: 40,
+    plan: 25,
+};
+function extractUrls(text) {
+    if (!text)
+        return [];
+    const urls = [];
+    for (const match of String(text).matchAll(URL_RE)) {
+        urls.push(match[0].replace(/[.,;:!?'"`]+$/, ''));
+    }
+    return urls;
+}
+function extractFilePaths(text, cwd) {
+    if (!text)
+        return [];
+    const home = os.homedir();
+    const base = cwd ? (0, node_path_1.resolve)(cwd) : process.cwd();
+    const paths = [];
+    for (const match of String(text).matchAll(PATH_RE)) {
+        let token = match[0].replace(/[.,;:)>"]+$/, '');
+        let line;
+        const lineMatch = /^(.+?):(\d+)(?::\d+)?$/.exec(token);
+        if (lineMatch) {
+            token = lineMatch[1];
+            line = Number(lineMatch[2]);
+        }
+        let file = token.startsWith('~') ? token.replace(/^~/, home) : token;
+        if (!(0, node_path_1.isAbsolute)(file))
+            file = (0, node_path_1.resolve)(base, file);
+        if (isExistingFile(file)) {
+            paths.push(line !== undefined ? { file, line } : { file });
+        }
+    }
+    return paths;
+}
+function extractCommands(text) {
+    if (!text)
+        return [];
+    const commands = [];
+    const source = String(text);
+    const fence = /```([\w.-]*)[ \t]*\r?\n([\s\S]*?)```/g;
+    const fencedSpans = [];
+    let match;
+    while ((match = fence.exec(source))) {
+        fencedSpans.push([match.index, fence.lastIndex]);
+        const shellTagged = SHELL_TAGS.has(match[1].toLowerCase());
+        let continuation = '';
+        for (const rawLine of match[2].split('\n')) {
+            const promptLine = /^\s*\$\s+(.+)$/.exec(rawLine);
+            if (promptLine) {
+                commands.push(promptLine[1].trim());
+                continue;
+            }
+            if (!shellTagged)
+                continue;
+            let line = rawLine.trim();
+            if (!line || line.startsWith('#'))
+                continue;
+            if (continuation) {
+                line = `${continuation} ${line}`;
+                continuation = '';
+            }
+            if (line.endsWith('\\')) {
+                continuation = line.slice(0, -1).trim();
+                continue;
+            }
+            commands.push(line);
+        }
+    }
+    for (const lineMatch of source.matchAll(/^[ \t]*\$[ \t]+(.+)$/gm)) {
+        const index = lineMatch.index ?? 0;
+        if (fencedSpans.some(([start, end]) => index >= start && index < end))
+            continue;
+        commands.push(lineMatch[1].trim());
+    }
+    return commands;
+}
+function urlAsset(url, timestamp, provenance = {}) {
+    return { type: 'url', text: url, display: url, timestamp, ...provenance };
+}
+function commandAsset(command, timestamp, provenance = {}) {
+    return { type: 'command', text: command, display: flat(command), timestamp, ...provenance };
+}
+function pathAsset(path, timestamp, provenance = {}) {
+    const text = path.line !== undefined ? `${path.file}:${path.line}` : path.file;
+    return { type: 'path', text, display: text, timestamp, ...provenance };
+}
+function planAsset(markdown, timestamp, provenance = {}) {
+    return { type: 'plan', text: markdown, display: planTitle(markdown), timestamp, ...provenance };
+}
+function flat(value) {
+    return value.replace(/\s*\n\s*/g, ' ').trim();
+}
+function planTitle(markdown) {
+    for (const rawLine of markdown.split('\n')) {
+        const line = rawLine.trim();
+        if (line)
+            return line.replace(/^#{1,6}\s*/, '');
+    }
+    return 'Plan';
+}
+function isExistingFile(filePath) {
+    try {
+        return fs.statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function readPlanFile(filePath) {
+    if (!filePath)
+        return undefined;
+    try {
+        return fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function byTimestampDesc(a, b) {
+    return (b.timestamp || '').localeCompare(a.timestamp || '');
+}
+function dedupeAssets(assets) {
+    const seen = new Set();
+    const deduped = [];
+    for (const asset of assets) {
+        if (!asset.text)
+            continue;
+        const key = `${asset.type}\0${asset.text}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(asset);
+    }
+    return deduped;
+}
+function dedupePlansByTitle(plans) {
+    const seen = new Set();
+    const deduped = [];
+    for (const plan of plans) {
+        const key = (plan.display || plan.text).trim().toLowerCase();
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(plan);
+    }
+    return deduped;
+}
+function capped(assets, cap) {
+    return cap > 0 ? assets.slice(0, cap) : assets;
+}

package/dist/extractors/sources/claudeAssets.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Claude Code transcript reader for actionable asset extraction.
+ *
+ * Portions adapted from `trawl` by Juan Fourie (B33pBeeps), MIT licensed:
+ * https://github.com/B33pBeeps/trawl
+ *
+ * @module extractors/sources/claudeAssets
+ */
+import { type SourceAssets } from '../sessionAssets';
+export declare function claudeSessions(cwd: string, limit?: number): string[];
+export declare function readClaudeAssets(cwd: string, limit?: number): SourceAssets;

package/dist/extractors/sources/claudeAssets.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * Claude Code transcript reader for actionable asset extraction.
+ *
+ * Portions adapted from `trawl` by Juan Fourie (B33pBeeps), MIT licensed:
+ * https://github.com/B33pBeeps/trawl
+ *
+ * @module extractors/sources/claudeAssets
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeSessions = claudeSessions;
+exports.readClaudeAssets = readClaudeAssets;
+const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
+const sessionPathResolver_1 = require("../../parsers/sessionPathResolver");
+const sessionAssets_1 = require("../sessionAssets");
+const PATH_TOOLS = new Set(['Read', 'Write', 'Edit', 'NotebookEdit']);
+function dirExists(path) {
+    try {
+        return (0, node_fs_1.statSync)(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function filesByMtimeDesc(dir, filter) {
+    let names;
+    try {
+        names = (0, node_fs_1.readdirSync)(dir);
+    }
+    catch {
+        return [];
+    }
+    return names
+        .filter(filter)
+        .map((name) => (0, node_path_1.join)(dir, name))
+        .map((filePath) => {
+        try {
+            return { path: filePath, mtime: (0, node_fs_1.statSync)(filePath).mtimeMs };
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((entry) => entry !== null)
+        .sort((a, b) => b.mtime - a.mtime)
+        .map((entry) => entry.path);
+}
+function readJsonl(filePath) {
+    let raw;
+    try {
+        raw = (0, node_fs_1.readFileSync)(filePath, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const lines = [];
+    for (const line of raw.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            lines.push(JSON.parse(trimmed));
+        }
+        catch {
+            // Ignore partial or malformed JSONL lines.
+        }
+    }
+    return lines;
+}
+function claudeSessions(cwd, limit = 3) {
+    const dir = (0, sessionPathResolver_1.getSessionDirectory)(cwd);
+    if (!dirExists(dir))
+        return [];
+    return filesByMtimeDesc(dir, (name) => name.endsWith('.jsonl')).slice(0, limit);
+}
+function asString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function provenance(sessionPath, source) {
+    return { agent: 'claude', sessionPath, source };
+}
+function addTextAssets(acc, text, cwd, timestamp, meta) {
+    for (const url of (0, sessionAssets_1.extractUrls)(text))
+        acc.urls.push((0, sessionAssets_1.urlAsset)(url, timestamp, meta));
+    for (const filePath of (0, sessionAssets_1.extractFilePaths)(text, cwd))
+        acc.paths.push((0, sessionAssets_1.pathAsset)(filePath, timestamp, meta));
+    for (const command of (0, sessionAssets_1.extractCommands)(text))
+        acc.commands.push((0, sessionAssets_1.commandAsset)(command, timestamp, meta));
+}
+function addToolPathAssets(acc, value, cwd, timestamp, meta) {
+    for (const filePath of (0, sessionAssets_1.extractFilePaths)(value, cwd)) {
+        acc.paths.push((0, sessionAssets_1.pathAsset)(filePath, timestamp, meta));
+    }
+}
+function accumClaude(filePath, cwd, acc) {
+    for (const line of readJsonl(filePath)) {
+        const timestamp = asString(line.timestamp);
+        if (line.type === 'attachment') {
+            const attachment = line.attachment;
+            const planFilePath = asString(attachment?.planFilePath);
+            if (planFilePath && (0, sessionAssets_1.isExistingFile)(planFilePath)) {
+                const text = (0, sessionAssets_1.readPlanFile)(planFilePath);
+                if (text?.trim())
+                    acc.plans.push((0, sessionAssets_1.planAsset)(text, timestamp, provenance(filePath, 'attachment:plan')));
+            }
+            continue;
+        }
+        const message = line.message;
+        const content = message?.content;
+        if (typeof content === 'string') {
+            addTextAssets(acc, content, cwd, timestamp, provenance(filePath, 'message'));
+            continue;
+        }
+        if (!Array.isArray(content))
+            continue;
+        for (const block of content) {
+            const typedBlock = block;
+            if (typedBlock.type === 'text') {
+                addTextAssets(acc, typedBlock.text, cwd, timestamp, provenance(filePath, 'message'));
+                continue;
+            }
+            if (typedBlock.type !== 'tool_use')
+                continue;
+            const name = asString(typedBlock.name);
+            const input = typedBlock.input || {};
+            const toolSource = name ? `tool:${name}` : 'tool';
+            const toolMeta = provenance(filePath, toolSource);
+            if (name === 'Bash') {
+                for (const url of (0, sessionAssets_1.extractUrls)(input.command))
+                    acc.urls.push((0, sessionAssets_1.urlAsset)(url, timestamp, toolMeta));
+                addToolPathAssets(acc, input.command, cwd, timestamp, toolMeta);
+            }
+            else if (name && PATH_TOOLS.has(name)) {
+                addToolPathAssets(acc, input.file_path, cwd, timestamp, toolMeta);
+            }
+            else if (name === 'WebFetch' || name === 'WebSearch') {
+                for (const url of (0, sessionAssets_1.extractUrls)(JSON.stringify(input)))
+                    acc.urls.push((0, sessionAssets_1.urlAsset)(url, timestamp, toolMeta));
+            }
+            else if (name === 'ExitPlanMode') {
+                const inline = asString(input.plan);
+                const markdown = inline?.trim() ? inline : (0, sessionAssets_1.readPlanFile)(asString(input.planFilePath));
+                if (markdown?.trim())
+                    acc.plans.push((0, sessionAssets_1.planAsset)(markdown, timestamp, toolMeta));
+            }
+        }
+    }
+}
+function readClaudeAssets(cwd, limit = 3) {
+    const sessions = claudeSessions(cwd, limit);
+    const acc = { urls: [], paths: [], commands: [], plans: [], hadSession: sessions.length > 0 };
+    for (const session of sessions)
+        accumClaude(session, cwd, acc);
+    return acc;
+}

package/dist/extractors/sources/codexAssets.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Codex CLI rollout reader for actionable asset extraction.
+ *
+ * Portions adapted from `trawl` by Juan Fourie (B33pBeeps), MIT licensed:
+ * https://github.com/B33pBeeps/trawl
+ *
+ * @module extractors/sources/codexAssets
+ */
+import { type SourceAssets } from '../sessionAssets';
+export declare function codexSessions(cwd: string, limit?: number): string[];
+export declare function readCodexAssets(cwd: string, limit?: number): SourceAssets;