sidekick-shared 0.26.5 → 0.27.0

package/dist/processDetection.js

@@ -0,0 +1,210 @@
+"use strict";
+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.ACCOUNT_CONSUMER_REACHABILITY = void 0;
+exports.findRunningProcessesSync = findRunningProcessesSync;
+exports.findRunningProcesses = findRunningProcesses;
+exports.detectRunningAccountConsumers = detectRunningAccountConsumers;
+exports.detectRunningAccountConsumersSync = detectRunningAccountConsumersSync;
+exports.describeAccountConsumer = describeAccountConsumer;
+/**
+ * Cross-platform detection of running CLI/app processes that hold provider
+ * credentials in memory. Bounded, never throws, never spawns a shell.
+ */
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const PROBE_TIMEOUT_MS = 4000;
+const CLAUDE_NPM_ENTRY = /claude-code[\\/]cli\.js/;
+function parseUnixTable(stdout) {
+    const rows = [];
+    for (const line of stdout.split('\n')) {
+        const match = line.match(/^\s*(\d+)\s+(\S+)\s*(.*)$/);
+        if (!match)
+            continue;
+        rows.push({ pid: Number(match[1]), command: match[2], args: match[3] ?? '' });
+    }
+    return rows;
+}
+function parseWindowsCsv(stdout) {
+    const rows = [];
+    for (const line of stdout.split(/\r?\n/)) {
+        const match = line.match(/^"([^"]+)","(\d+)"/);
+        if (!match)
+            continue;
+        rows.push({ pid: Number(match[2]), command: match[1], args: '' });
+    }
+    return rows;
+}
+function matchRows(rows, names) {
+    const wanted = new Set(names);
+    const found = [];
+    for (const row of rows) {
+        if (!Number.isFinite(row.pid) || row.pid === process.pid)
+            continue;
+        const base = path.basename(row.command);
+        // The native Claude Code binary is invoked through a `claude` symlink but
+        // its executable is the versioned file (`.../versions/2.1.273`), so `comm`
+        // never says `claude`; argv[0] does.
+        const argv0 = row.args.trim().split(/\s+/)[0] ?? '';
+        const candidates = [base, base.replace(/\.exe$/i, ''), path.basename(argv0)];
+        let name = candidates.find((candidate) => candidate && wanted.has(candidate));
+        // An npm-installed `claude` runs under `node`; recognise it by its entry file.
+        if (!name &&
+            wanted.has('claude') &&
+            /^node(\.exe)?$/i.test(base) &&
+            CLAUDE_NPM_ENTRY.test(row.args)) {
+            name = 'claude';
+        }
+        if (name)
+            found.push({ pid: row.pid, name, command: row.command });
+    }
+    return found;
+}
+function probeCommand() {
+    return process.platform === 'win32'
+        ? { command: 'tasklist', args: ['/FO', 'CSV', '/NH'] }
+        : { command: 'ps', args: ['-axo', 'pid=,comm=,args='] };
+}
+function parseOutput(stdout) {
+    return process.platform === 'win32' ? parseWindowsCsv(stdout) : parseUnixTable(stdout);
+}
+/** Sync sibling of {@link findRunningProcesses}; blocks up to 4 s. */
+function findRunningProcessesSync(names) {
+    if (names.length === 0)
+        return [];
+    try {
+        const { command, args } = probeCommand();
+        const result = (0, child_process_1.spawnSync)(command, args, {
+            encoding: 'utf8',
+            maxBuffer: 16 * 1024 * 1024,
+            timeout: PROBE_TIMEOUT_MS,
+            killSignal: 'SIGKILL',
+            windowsHide: true,
+        });
+        if (result.error || result.status !== 0)
+            return [];
+        return matchRows(parseOutput(String(result.stdout ?? '')), names);
+    }
+    catch {
+        return [];
+    }
+}
+function findRunningProcesses(names) {
+    if (names.length === 0)
+        return Promise.resolve([]);
+    return new Promise((resolve) => {
+        try {
+            const { command, args } = probeCommand();
+            (0, child_process_1.execFile)(command, args, {
+                encoding: 'utf8',
+                timeout: PROBE_TIMEOUT_MS,
+                killSignal: 'SIGKILL',
+                windowsHide: true,
+                maxBuffer: 16 * 1024 * 1024,
+            }, (error, stdout) => {
+                resolve(error ? [] : matchRows(parseOutput(String(stdout ?? '')), names));
+            });
+        }
+        catch {
+            resolve([]);
+        }
+    });
+}
+const CONSUMER_PROCESS_NAMES = {
+    'claude-cli': 'claude',
+    'claude-desktop': 'Claude',
+    'codex-cli': 'codex',
+    'codex-app': 'Codex',
+};
+exports.ACCOUNT_CONSUMER_REACHABILITY = {
+    'claude-cli': {
+        switched: true,
+        reachability: 'Running claude sessions keep the previous account until restarted; a running session can rotate the refresh token of the account you just left.',
+    },
+    'claude-desktop': {
+        switched: false,
+        reachability: 'Claude Desktop is not switched by sidekick (it keeps its own web session) and its embedded engine can rotate the shared CLI token.',
+    },
+    'codex-cli': {
+        switched: true,
+        reachability: 'Running codex sessions keep the previous account until restarted.',
+    },
+    'codex-app': {
+        switched: true,
+        reachability: 'The Codex app shares the CLI login; restart it to pick up the switch. While running it can refresh and rotate the live token.',
+    },
+    'vscode-extension-host': {
+        switched: true,
+        reachability: 'The Claude Code extension host keeps the previous account until the window reloads.',
+    },
+};
+function toConsumer(kind, pids) {
+    return { kind, pids, ...exports.ACCOUNT_CONSUMER_REACHABILITY[kind] };
+}
+function groupConsumers(processes, kinds) {
+    const consumers = [];
+    for (const kind of kinds) {
+        const pids = processes.filter((p) => p.name === CONSUMER_PROCESS_NAMES[kind]).map((p) => p.pid);
+        if (pids.length > 0)
+            consumers.push(toConsumer(kind, pids));
+    }
+    return consumers;
+}
+function kindsForProvider(provider) {
+    if (provider === 'claude-code')
+        return ['claude-cli', 'claude-desktop'];
+    if (provider === 'codex')
+        return ['codex-cli', 'codex-app'];
+    return ['claude-cli', 'claude-desktop', 'codex-cli', 'codex-app'];
+}
+/**
+ * Which credential consumers are running right now, with the reachability
+ * sentence to show for each. Optionally scoped to one provider.
+ */
+async function detectRunningAccountConsumers(provider) {
+    const kinds = kindsForProvider(provider);
+    const processes = await findRunningProcesses(kinds.map((kind) => CONSUMER_PROCESS_NAMES[kind]));
+    return groupConsumers(processes, kinds);
+}
+/** Sync sibling of {@link detectRunningAccountConsumers}; blocks up to 4 s. */
+function detectRunningAccountConsumersSync(provider) {
+    const kinds = kindsForProvider(provider);
+    const processes = findRunningProcessesSync(kinds.map((kind) => CONSUMER_PROCESS_NAMES[kind]));
+    return groupConsumers(processes, kinds);
+}
+/** Build a consumer entry for a kind the host detects itself (e.g. its own extension host). */
+function describeAccountConsumer(kind, pids = []) {
+    return toConsumer(kind, pids);
+}

package/dist/promptHistory.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Node-only collection of human-typed prompts from Claude Code and Codex
+ * session logs, scoped to a set of workspace roots.
+ *
+ * Parse-only: no redaction and no network I/O. Scope fails closed — a prompt
+ * is returned only when the working directory recorded on its log line (or,
+ * for Codex, its session/turn context) realpath-resolves to an allowed root
+ * or somewhere inside one. Every bound stops cleanly and is reported in
+ * `boundsHit`; nothing is silently truncated and no bound throws.
+ */
+import { type HumanPromptProvider } from './humanPrompt';
+export type PromptHistoryProvider = HumanPromptProvider;
+export type PromptHistoryBound = 'maxSessions' | 'maxFileBytes' | 'maxTotalBytes' | 'deadline' | 'aborted';
+export interface PromptHistoryBounds {
+    /** Session files read in one call (unchanged files do not count). Default 1000. */
+    maxSessions?: number;
+    /** Bytes a single file may need read in this pass. Default 16 MiB. */
+    maxFileBytes?: number;
+    /** Bytes read across all files in this call. Default 256 MiB. */
+    maxTotalBytes?: number;
+    /** Wall-clock budget for the call. Default 30 000 ms. */
+    deadlineMs?: number;
+}
+/** Codex parse state carried across resumes (Claude lines are self-describing). */
+export interface PromptHistoryResumeState {
+    cwd?: string;
+    gitBranch?: string;
+    model?: string;
+    /** Session is not interactive (non-human source, fork, or missing metadata). */
+    excluded?: boolean;
+    /** `session_meta` has been seen. */
+    meta?: boolean;
+}
+export interface PromptHistoryCursorSession {
+    provider: PromptHistoryProvider;
+    sessionId: string;
+    size: number;
+    mtimeMs: number;
+    /** Ordinal of the last human prompt seen in this file, or -1 when none. */
+    lastOrdinal: number;
+    /** Byte offset just past the last complete line processed. */
+    offset: number;
+    state?: PromptHistoryResumeState;
+}
+/** JSON-serializable resume point. Keys are opaque; they never contain paths. */
+export interface PromptHistoryCursor {
+    version: 1;
+    sessions: Record<string, PromptHistoryCursorSession>;
+}
+export interface PromptHistoryUsage {
+    /** Uncached input tokens. */
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+}
+export interface PromptHistoryEntry {
+    provider: PromptHistoryProvider;
+    sessionId: string;
+    /** Stable index of this prompt among the session's human prompts (0-based). */
+    ordinal: number;
+    /** ISO timestamp from the log line; never synthesized. */
+    timestamp: string;
+    /** Full prompt text, untruncated. */
+    text: string;
+    /** Realpath of the working directory; always inside an allowed root. */
+    cwd: string;
+    gitBranch?: string;
+    /** Model of the first assistant response to this prompt, when known. */
+    model?: string;
+    /** Usage of that first answering model call, when known. */
+    usage?: PromptHistoryUsage;
+}
+export interface PromptHistoryStats {
+    sessionsScanned: number;
+    sessionsSkippedUnchanged: number;
+    /** Scanned sessions with human prompts but none inside the allowed roots. */
+    sessionsOutOfScope: number;
+    filesOverSizeLimit: number;
+    /** Codex sessions skipped as non-interactive (subagent, fork, unknown source). */
+    sessionsNotInteractive: number;
+    /** Human prompts dropped because the log line had no usable timestamp. */
+    promptsMissingTimestamp: number;
+    /** Human prompts dropped because their cwd was missing or outside the roots. */
+    promptsOutOfScope: number;
+}
+export interface CollectPromptHistoryOptions {
+    /** Absolute workspace roots; realpath-normalized internally. */
+    workspacePaths: string[];
+    /** Add git worktree siblings of each root. Default true. */
+    includeWorktrees?: boolean;
+    /** Default both. */
+    providers?: PromptHistoryProvider[];
+    /** Drop prompts older than this (and skip files not modified since). */
+    since?: Date;
+    cursor?: PromptHistoryCursor;
+    bounds?: PromptHistoryBounds;
+    signal?: AbortSignal;
+}
+export interface PromptHistoryResult {
+    /** Ordered by provider, session, then ordinal. */
+    entries: PromptHistoryEntry[];
+    cursor: PromptHistoryCursor;
+    stats: PromptHistoryStats;
+    boundsHit: PromptHistoryBound[];
+}
+/** Collect human-typed prompts from Claude Code and Codex logs under the given roots. */
+export declare function collectPromptHistory(options: CollectPromptHistoryOptions): Promise<PromptHistoryResult>;