hanzi-browse 2.2.0

package/dist/cli/detect-credentials.js

@@ -0,0 +1,44 @@
+/**
+ * Credential source detection for CLI setup.
+ *
+ * Claude Code stores OAuth tokens in one of two locations:
+ *   1. ~/.claude/.credentials.json (file-based, all platforms)
+ *   2. macOS Keychain under "Claude Code-credentials" (macOS only)
+ *
+ * The original implementation only checked (1), missing most macOS users.
+ */
+import { join } from 'path';
+// ── Constants ────────────────────────────────────────────────────────
+const KEYCHAIN_SERVICE = 'Claude Code-credentials';
+// ── Detection ────────────────────────────────────────────────────────
+export function detectCredentialSources(opts) {
+    const { platform, homedir, fileExists, keychainHas } = opts;
+    const found = [];
+    const claudePath = join(homedir, '.claude', '.credentials.json');
+    if (fileExists(claudePath)) {
+        found.push({ name: 'Claude Code', slug: 'claude', path: claudePath });
+    }
+    else if (platform === 'darwin' && keychainHas(KEYCHAIN_SERVICE)) {
+        found.push({ name: 'Claude Code', slug: 'claude', path: 'macOS Keychain' });
+    }
+    const codexPath = join(homedir, '.codex', 'auth.json');
+    if (fileExists(codexPath)) {
+        found.push({ name: 'Codex CLI', slug: 'codex', path: codexPath });
+    }
+    return found;
+}
+// ── Flow state check ─────────────────────────────────────────────────
+/**
+ * Returns an error message if setup finished with no credentials configured,
+ * or null if everything is fine.
+ */
+export function checkCredentialFlowResult(state) {
+    if (state.sourcesDetected === 0)
+        return null;
+    if (state.anyImported)
+        return null;
+    if (state.manualEntryChosen)
+        return null;
+    return 'No credentials configured. The extension needs a model source to run tasks.\n'
+        + 'Add one later in the Chrome extension sidepanel → Settings.';
+}

package/dist/cli/import-credentials-handler.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Credential import handler for mcp-bridge.
+ *
+ * The original mcp-bridge used chrome.runtime.sendMessage() which cannot
+ * message the service worker from within itself ("Receiving end does not
+ * exist"). This provides a direct-call handler using Result types.
+ */
+import { ResultAsync } from 'neverthrow';
+export interface ImportDeps {
+    importCLI: () => Promise<unknown>;
+    importCodex: () => Promise<unknown>;
+    loadConfig: () => Promise<null>;
+}
+export declare function handleImportCredentials(source: unknown, deps: ImportDeps): ResultAsync<unknown, string>;

package/dist/cli/import-credentials-handler.js

@@ -0,0 +1,22 @@
+/**
+ * Credential import handler for mcp-bridge.
+ *
+ * The original mcp-bridge used chrome.runtime.sendMessage() which cannot
+ * message the service worker from within itself ("Receiving end does not
+ * exist"). This provides a direct-call handler using Result types.
+ */
+import { err, ResultAsync } from 'neverthrow';
+// ── Guard ────────────────────────────────────────────────────────────
+function isValidSource(source) {
+    return source === 'claude' || source === 'codex';
+}
+// ── Handler ──────────────────────────────────────────────────────────
+export function handleImportCredentials(source, deps) {
+    if (!isValidSource(source)) {
+        return new ResultAsync(Promise.resolve(err(`Unknown credential source: ${source}`)));
+    }
+    const importFn = source === 'claude' ? deps.importCLI : deps.importCodex;
+    return ResultAsync.fromPromise(importFn(), (e) => e.message)
+        .andThen((credentials) => ResultAsync.fromPromise(deps.loadConfig(), (e) => e.message)
+        .map(() => credentials));
+}

package/dist/cli/session-files.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Session Files Module
+ *
+ * Manages file-based session storage for the CLI.
+ * Sessions are stored as JSON files in ~/.hanzi-browse/sessions/
+ */
+export interface SessionFileStatus {
+    session_id: string;
+    status: 'starting' | 'running' | 'complete' | 'error' | 'stopped';
+    task: string;
+    url?: string;
+    context?: string;
+    started_at: string;
+    updated_at: string;
+    result?: string;
+    error?: string;
+}
+export declare function ensureSessionDir(): void;
+export declare function getSessionFilePath(sessionId: string): string;
+export declare function getSessionLogPath(sessionId: string): string;
+export declare function getSessionScreenshotPath(sessionId: string): string;
+export declare function writeSessionStatus(sessionId: string, status: Partial<SessionFileStatus>): void;
+export declare function readSessionStatus(sessionId: string): SessionFileStatus | null;
+export declare function appendSessionLog(sessionId: string, message: string): void;
+export declare function readSessionLog(sessionId: string, lines?: number): string;
+export declare function listSessions(): SessionFileStatus[];
+export declare function listActiveSessions(): SessionFileStatus[];
+export declare function deleteSessionFiles(sessionId: string): boolean;

package/dist/cli/session-files.js

@@ -0,0 +1,118 @@
+/**
+ * Session Files Module
+ *
+ * Manages file-based session storage for the CLI.
+ * Sessions are stored as JSON files in ~/.hanzi-browse/sessions/
+ */
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync, appendFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+// Session directory
+const SESSION_DIR = join(homedir(), '.hanzi-browse', 'sessions');
+export function ensureSessionDir() {
+    mkdirSync(SESSION_DIR, { recursive: true });
+}
+export function getSessionFilePath(sessionId) {
+    return join(SESSION_DIR, `${sessionId}.json`);
+}
+export function getSessionLogPath(sessionId) {
+    return join(SESSION_DIR, `${sessionId}.log`);
+}
+export function getSessionScreenshotPath(sessionId) {
+    return join(SESSION_DIR, `${sessionId}.png`);
+}
+export function writeSessionStatus(sessionId, status) {
+    ensureSessionDir();
+    const filePath = getSessionFilePath(sessionId);
+    let current;
+    if (existsSync(filePath)) {
+        try {
+            current = JSON.parse(readFileSync(filePath, 'utf-8'));
+        }
+        catch {
+            current = createInitialStatus(sessionId);
+        }
+    }
+    else {
+        current = createInitialStatus(sessionId);
+    }
+    const updated = {
+        ...current,
+        ...status,
+        updated_at: new Date().toISOString(),
+    };
+    writeFileSync(filePath, JSON.stringify(updated, null, 2));
+}
+function createInitialStatus(sessionId) {
+    const now = new Date().toISOString();
+    return {
+        session_id: sessionId,
+        status: 'starting',
+        task: '',
+        started_at: now,
+        updated_at: now,
+    };
+}
+export function readSessionStatus(sessionId) {
+    const filePath = getSessionFilePath(sessionId);
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(filePath, 'utf-8'));
+    }
+    catch (err) {
+        console.error(`[Session] Failed to parse ${sessionId}.json:`, err.message);
+        return null;
+    }
+}
+export function appendSessionLog(sessionId, message) {
+    ensureSessionDir();
+    const logPath = getSessionLogPath(sessionId);
+    const timestamp = new Date().toISOString();
+    appendFileSync(logPath, `[${timestamp}] ${message}\n`);
+}
+export function readSessionLog(sessionId, lines) {
+    const logPath = getSessionLogPath(sessionId);
+    if (!existsSync(logPath)) {
+        return '';
+    }
+    const content = readFileSync(logPath, 'utf-8');
+    if (lines) {
+        const allLines = content.split('\n');
+        return allLines.slice(-lines).join('\n');
+    }
+    return content;
+}
+export function listSessions() {
+    ensureSessionDir();
+    const files = readdirSync(SESSION_DIR).filter(f => f.endsWith('.json'));
+    const sessions = [];
+    for (const file of files) {
+        const sessionId = file.replace('.json', '');
+        const status = readSessionStatus(sessionId);
+        if (status) {
+            sessions.push(status);
+        }
+    }
+    sessions.sort((a, b) => new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime());
+    return sessions;
+}
+export function listActiveSessions() {
+    return listSessions().filter(s => s.status === 'starting' ||
+        s.status === 'running');
+}
+export function deleteSessionFiles(sessionId) {
+    const statusPath = getSessionFilePath(sessionId);
+    const logPath = getSessionLogPath(sessionId);
+    let deleted = false;
+    if (existsSync(statusPath)) {
+        unlinkSync(statusPath);
+        deleted = true;
+    }
+    if (existsSync(logPath)) {
+        unlinkSync(logPath);
+        deleted = true;
+    }
+    return deleted;
+}

package/dist/cli/setup.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `hanzi-browser setup` — auto-detect AI agents and inject MCP config.
+ *
+ * Scans the machine for Claude Code, Cursor, Windsurf, and Claude Desktop,
+ * then merges the Hanzi MCP server entry into each agent's config file.
+ */
+export declare function runSetup(options?: {
+    only?: string;
+    yes?: boolean;
+}): Promise<void>;