@nntoan/gstack 0.0.1

package/dist/config/merge-configs.d.ts

@@ -0,0 +1,2 @@
+import type { GstackConfig } from '../types/config.ts';
+export declare function mergeConfigs(base: GstackConfig, override: Partial<GstackConfig>): GstackConfig;

package/dist/config/schema/agent-schema.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const AgentOverrideSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    instructions: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const AgentOverridesSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    instructions: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+export type AgentOverride = z.infer<typeof AgentOverrideSchema>;
+export type AgentOverrides = z.infer<typeof AgentOverridesSchema>;

package/dist/config/schema/backlog-schema.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export declare const BacklogConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    auto_create_tasks: z.ZodDefault<z.ZodBoolean>;
+    auto_update_status: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type BacklogConfig = z.infer<typeof BacklogConfigSchema>;

package/dist/config/schema/browser-schema.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare const BrowserConfigSchema: z.ZodObject<{
+    headless: z.ZodDefault<z.ZodBoolean>;
+    timeout_ms: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type BrowserConfig = z.infer<typeof BrowserConfigSchema>;

package/dist/config/schema/constants.d.ts

@@ -0,0 +1 @@
+export declare const SCHEMA_URL = "https://raw.githubusercontent.com/nntoan/opencode-gstack/main/schemas/config.schema.json";

package/dist/config/schema/index.d.ts

@@ -0,0 +1,7 @@
+export { AgentOverrideSchema, AgentOverridesSchema, type AgentOverride, type AgentOverrides, } from './agent-schema.ts';
+export { WebsearchMcpSchema, Context7McpSchema, ContexthubMcpSchema, GrepAppMcpSchema, BacklogMdMcpSchema, McpConfigSchema, type WebsearchMcpConfig, type Context7McpConfig, type ContexthubMcpConfig, type GrepAppMcpConfig, type BacklogMdMcpConfig, type McpConfig, } from './mcp-schema.ts';
+export { BacklogConfigSchema, type BacklogConfig } from './backlog-schema.ts';
+export { BrowserConfigSchema, type BrowserConfig } from './browser-schema.ts';
+export { TelemetryConfigSchema, type TelemetryConfig } from './telemetry-schema.ts';
+export { GstackConfigSchema, type GstackConfigOutput } from './main.ts';
+export { SCHEMA_URL } from './constants.ts';

package/dist/config/schema/main.d.ts

@@ -0,0 +1,150 @@
+import { z } from 'zod';
+export declare const GstackConfigSchema: z.ZodPipe<z.ZodObject<{
+    orchestration_mode: z.ZodDefault<z.ZodEnum<{
+        "multi-agent": "multi-agent";
+        "skills-only": "skills-only";
+    }>>;
+    disabled_skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    disabled_agents: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    disabled_mcps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    disabled_hooks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        instructions: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    mcp: z.ZodOptional<z.ZodObject<{
+        websearch: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodDefault<z.ZodEnum<{
+                exa: "exa";
+                tavily: "tavily";
+            }>>;
+            api_key: z.ZodOptional<z.ZodString>;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        context7: z.ZodOptional<z.ZodObject<{
+            api_key: z.ZodOptional<z.ZodString>;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        contexthub: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        grep_app: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        backlog_md: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    backlog: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        auto_create_tasks: z.ZodDefault<z.ZodBoolean>;
+        auto_update_status: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    browser: z.ZodOptional<z.ZodObject<{
+        headless: z.ZodDefault<z.ZodBoolean>;
+        timeout_ms: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    telemetry: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        supabase: z.ZodOptional<z.ZodObject<{
+            url: z.ZodOptional<z.ZodString>;
+            key: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodTransform<{
+    backlog: {
+        enabled: boolean;
+        auto_create_tasks: boolean;
+        auto_update_status: boolean;
+    };
+    orchestration_mode: "multi-agent" | "skills-only";
+    disabled_skills: string[];
+    disabled_agents: string[];
+    disabled_mcps: string[];
+    disabled_hooks: string[];
+    agents?: Record<string, {
+        model?: string | undefined;
+        instructions?: string | undefined;
+        enabled?: boolean | undefined;
+    }> | undefined;
+    mcp?: {
+        websearch?: {
+            provider: "exa" | "tavily";
+            enabled: boolean;
+            api_key?: string | undefined;
+        } | undefined;
+        context7?: {
+            enabled: boolean;
+            api_key?: string | undefined;
+        } | undefined;
+        contexthub?: {
+            enabled: boolean;
+        } | undefined;
+        grep_app?: {
+            enabled: boolean;
+        } | undefined;
+        backlog_md?: {
+            enabled: boolean;
+        } | undefined;
+    } | undefined;
+    browser?: {
+        headless: boolean;
+        timeout_ms: number;
+    } | undefined;
+    telemetry?: {
+        enabled: boolean;
+        supabase?: {
+            url?: string | undefined;
+            key?: string | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    orchestration_mode: "multi-agent" | "skills-only";
+    disabled_skills: string[];
+    disabled_agents: string[];
+    disabled_mcps: string[];
+    disabled_hooks: string[];
+    agents?: Record<string, {
+        model?: string | undefined;
+        instructions?: string | undefined;
+        enabled?: boolean | undefined;
+    }> | undefined;
+    mcp?: {
+        websearch?: {
+            provider: "exa" | "tavily";
+            enabled: boolean;
+            api_key?: string | undefined;
+        } | undefined;
+        context7?: {
+            enabled: boolean;
+            api_key?: string | undefined;
+        } | undefined;
+        contexthub?: {
+            enabled: boolean;
+        } | undefined;
+        grep_app?: {
+            enabled: boolean;
+        } | undefined;
+        backlog_md?: {
+            enabled: boolean;
+        } | undefined;
+    } | undefined;
+    backlog?: {
+        enabled: boolean;
+        auto_create_tasks: boolean;
+        auto_update_status: boolean;
+    } | undefined;
+    browser?: {
+        headless: boolean;
+        timeout_ms: number;
+    } | undefined;
+    telemetry?: {
+        enabled: boolean;
+        supabase?: {
+            url?: string | undefined;
+            key?: string | undefined;
+        } | undefined;
+    } | undefined;
+}>>;
+export type GstackConfigOutput = z.infer<typeof GstackConfigSchema>;

package/dist/config/schema/mcp-schema.d.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export declare const WebsearchMcpSchema: z.ZodObject<{
+    provider: z.ZodDefault<z.ZodEnum<{
+        exa: "exa";
+        tavily: "tavily";
+    }>>;
+    api_key: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const Context7McpSchema: z.ZodObject<{
+    api_key: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const ContexthubMcpSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const GrepAppMcpSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const BacklogMdMcpSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const McpConfigSchema: z.ZodObject<{
+    websearch: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodDefault<z.ZodEnum<{
+            exa: "exa";
+            tavily: "tavily";
+        }>>;
+        api_key: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    context7: z.ZodOptional<z.ZodObject<{
+        api_key: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    contexthub: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    grep_app: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    backlog_md: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type WebsearchMcpConfig = z.infer<typeof WebsearchMcpSchema>;
+export type Context7McpConfig = z.infer<typeof Context7McpSchema>;
+export type ContexthubMcpConfig = z.infer<typeof ContexthubMcpSchema>;
+export type GrepAppMcpConfig = z.infer<typeof GrepAppMcpSchema>;
+export type BacklogMdMcpConfig = z.infer<typeof BacklogMdMcpSchema>;
+export type McpConfig = z.infer<typeof McpConfigSchema>;

package/dist/config/schema/telemetry-schema.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const TelemetryConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    supabase: z.ZodOptional<z.ZodObject<{
+        url: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TelemetryConfig = z.infer<typeof TelemetryConfigSchema>;

package/dist/create-hooks.d.ts

@@ -0,0 +1,9 @@
+import type { GstackConfig } from './types/config.ts';
+import type { Managers } from './create-managers.ts';
+export declare function createHooks(_params: {
+    ctx: {
+        directory: string;
+    };
+    pluginConfig: GstackConfig;
+    managers: Managers;
+}): Record<string, unknown>;

package/dist/create-managers.d.ts

@@ -0,0 +1,17 @@
+import type { GstackConfig } from './types/config.ts';
+import type { GstackSkill } from './types/skill.ts';
+import { SkillMcpManager } from './features/skill-mcp-manager/index.ts';
+import { createConfigHandler } from './plugin-handlers/index.ts';
+import type { SprintBacklog } from './features/sprint-backlog/index.ts';
+export interface Managers {
+    skillMcpManager: SkillMcpManager;
+    configHandler: ReturnType<typeof createConfigHandler>;
+    sprintBacklog: SprintBacklog;
+}
+export declare function createManagers(params: {
+    ctx: {
+        directory: string;
+    };
+    pluginConfig: GstackConfig;
+    skills?: GstackSkill[];
+}): Managers;

package/dist/create-skills-and-agents.d.ts

@@ -0,0 +1,8 @@
+import type { GstackConfig } from './types/config.ts';
+import type { GstackSkill } from './types/skill.ts';
+import type { GstackAgent } from './types/agent.ts';
+export interface SkillsAndAgents {
+    skills: GstackSkill[];
+    agents: GstackAgent[];
+}
+export declare function createSkillsAndAgents(config: GstackConfig): SkillsAndAgents;

package/dist/create-tools.d.ts

@@ -0,0 +1,9 @@
+import type { GstackConfig } from './types/config.ts';
+import type { Managers } from './create-managers.ts';
+export declare function createTools(_params: {
+    ctx: {
+        directory: string;
+    };
+    pluginConfig: GstackConfig;
+    managers: Managers;
+}): Record<string, unknown>;

package/dist/features/analytics/eureka-tracker.d.ts

@@ -0,0 +1,2 @@
+import type { AnalyticsOptions, EurekaTracker } from './types.ts';
+export declare function createEurekaTracker(options: AnalyticsOptions): EurekaTracker;

package/dist/features/analytics/index.d.ts

@@ -0,0 +1,12 @@
+export type { AnalyticsOptions, EurekaEvent, EurekaTracker, SkillUsageEvent, SkillUsageTracker, SprintLogEvent, SprintLogger, } from './types.ts';
+export { appendJsonl, readJsonl } from './writer.ts';
+export { createEurekaTracker } from './eureka-tracker.ts';
+export { createSkillUsageTracker } from './skill-usage-tracker.ts';
+export { createSprintLogger } from './sprint-logger.ts';
+import type { AnalyticsOptions, EurekaTracker, SkillUsageTracker, SprintLogger } from './types.ts';
+export interface Analytics {
+    skillUsage: SkillUsageTracker;
+    eureka: EurekaTracker;
+    sprintLog: SprintLogger;
+}
+export declare function createAnalytics(options: AnalyticsOptions): Analytics;

package/dist/features/analytics/skill-usage-tracker.d.ts

@@ -0,0 +1,2 @@
+import type { AnalyticsOptions, SkillUsageTracker } from './types.ts';
+export declare function createSkillUsageTracker(options: AnalyticsOptions): SkillUsageTracker;

package/dist/features/analytics/sprint-logger.d.ts

@@ -0,0 +1,2 @@
+import type { AnalyticsOptions, SprintLogger } from './types.ts';
+export declare function createSprintLogger(options: AnalyticsOptions): SprintLogger;

package/dist/features/analytics/types.d.ts

@@ -0,0 +1,38 @@
+import type { SprintPhase } from '../../types/agent.ts';
+export interface SkillUsageEvent {
+    timestamp: string;
+    skillName: string;
+    duration: number;
+    success: boolean;
+    phase?: SprintPhase;
+    version: string;
+}
+export interface EurekaEvent {
+    timestamp: string;
+    skillName: string;
+    insight: string;
+    category: 'learning' | 'bug' | 'optimization' | 'pattern';
+}
+export interface SprintLogEvent {
+    timestamp: string;
+    phase: SprintPhase;
+    action: 'started' | 'completed' | 'skipped';
+    agent?: string;
+    taskId?: string;
+}
+export interface AnalyticsOptions {
+    analyticsDir: string;
+    enabled: boolean;
+}
+export interface SkillUsageTracker {
+    record(event: SkillUsageEvent): void;
+    getRecent(limit: number): SkillUsageEvent[];
+}
+export interface EurekaTracker {
+    record(event: EurekaEvent): void;
+    getInsights(skillName?: string): EurekaEvent[];
+}
+export interface SprintLogger {
+    log(event: SprintLogEvent): void;
+    getPhaseHistory(): SprintLogEvent[];
+}

package/dist/features/analytics/writer.d.ts

@@ -0,0 +1,2 @@
+export declare function appendJsonl(filePath: string, event: Record<string, unknown>): Promise<void>;
+export declare function readJsonl<T>(filePath: string): T[];

package/dist/features/browser-daemon/browser-manager.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Browser lifecycle manager
+ *
+ * Chromium crash handling:
+ *   browser.on('disconnected') → log error → process.exit(1)
+ *   CLI detects dead server → auto-restarts on next command
+ *   We do NOT try to self-heal — don't hide failure.
+ *
+ * Dialog handling:
+ *   page.on('dialog') → auto-accept by default → store in dialog buffer
+ *   Prevents browser lockup from alert/confirm/prompt
+ *
+ * Context recreation (useragent):
+ *   recreateContext() saves cookies/storage/URLs, creates new context,
+ *   restores state. Falls back to clean slate on any failure.
+ */
+import { type Cookie, type Locator, type Page } from 'playwright';
+export interface RefEntry {
+    locator: Locator;
+    role: string;
+    name: string;
+}
+export interface BrowserState {
+    cookies: Cookie[];
+    pages: Array<{
+        url: string;
+        isActive: boolean;
+        storage: {
+            localStorage: Record<string, string>;
+            sessionStorage: Record<string, string>;
+        } | null;
+    }>;
+}
+export declare class BrowserManager {
+    private browser;
+    private context;
+    private pages;
+    private activeTabId;
+    private nextTabId;
+    private extraHeaders;
+    private customUserAgent;
+    /** Server port — set after server starts, used by cookie-import-browser command */
+    serverPort: number;
+    private refMap;
+    private lastSnapshot;
+    private dialogAutoAccept;
+    private dialogPromptText;
+    private isHeaded;
+    private consecutiveFailures;
+    launch(): Promise<void>;
+    close(): Promise<void>;
+    isHealthy(): Promise<boolean>;
+    newTab(url?: string): Promise<number>;
+    closeTab(id?: number): Promise<void>;
+    switchTab(id: number): void;
+    getTabCount(): number;
+    getTabListWithTitles(): Promise<Array<{
+        id: number;
+        url: string;
+        title: string;
+        active: boolean;
+    }>>;
+    getPage(): Page;
+    getCurrentUrl(): string;
+    setRefMap(refs: Map<string, RefEntry>): void;
+    clearRefs(): void;
+    /**
+     * Resolve a selector that may be a @ref (e.g., "@e3", "@c1") or a CSS selector.
+     * Returns { locator } for refs or { selector } for CSS selectors.
+     */
+    resolveRef(selector: string): Promise<{
+        locator: Locator;
+    } | {
+        selector: string;
+    }>;
+    /** Get the ARIA role for a ref selector, or null for CSS selectors / unknown refs. */
+    getRefRole(selector: string): string | null;
+    getRefCount(): number;
+    setLastSnapshot(text: string | null): void;
+    getLastSnapshot(): string | null;
+    setDialogAutoAccept(accept: boolean): void;
+    getDialogAutoAccept(): boolean;
+    setDialogPromptText(text: string | null): void;
+    getDialogPromptText(): string | null;
+    setViewport(width: number, height: number): Promise<void>;
+    setExtraHeader(name: string, value: string): Promise<void>;
+    setUserAgent(ua: string): void;
+    getUserAgent(): string | null;
+    saveState(): Promise<BrowserState>;
+    restoreState(state: BrowserState): Promise<void>;
+    recreateContext(): Promise<string | null>;
+    handoff(message: string): Promise<string>;
+    resume(): void;
+    getIsHeaded(): boolean;
+    incrementFailures(): void;
+    resetFailures(): void;
+    getFailureHint(): string | null;
+    private wirePageEvents;
+}

package/dist/features/browser-daemon/buffers.d.ts

@@ -0,0 +1,43 @@
+export declare class CircularBuffer<T> {
+    private buffer;
+    private head;
+    private _size;
+    private _totalAdded;
+    readonly capacity: number;
+    constructor(capacity: number);
+    push(entry: T): void;
+    toArray(): T[];
+    last(n: number): T[];
+    get length(): number;
+    get totalAdded(): number;
+    clear(): void;
+    get(index: number): T | undefined;
+    set(index: number, entry: T): void;
+}
+export interface LogEntry {
+    timestamp: number;
+    level: string;
+    text: string;
+}
+export interface NetworkEntry {
+    timestamp: number;
+    method: string;
+    url: string;
+    status?: number;
+    duration?: number;
+    size?: number;
+}
+export interface DialogEntry {
+    timestamp: number;
+    type: string;
+    message: string;
+    defaultValue?: string;
+    action: string;
+    response?: string;
+}
+export declare const consoleBuffer: CircularBuffer<LogEntry>;
+export declare const networkBuffer: CircularBuffer<NetworkEntry>;
+export declare const dialogBuffer: CircularBuffer<DialogEntry>;
+export declare function addConsoleEntry(entry: LogEntry): void;
+export declare function addNetworkEntry(entry: NetworkEntry): void;
+export declare function addDialogEntry(entry: DialogEntry): void;

package/dist/features/browser-daemon/cli.d.ts

@@ -0,0 +1,12 @@
+/**
+ * gstack browse CLI — thin wrapper that talks to the persistent server
+ *
+ * Flow:
+ *   1. Read .gstack/browser/browse.json for port + token
+ *   2. If missing or stale PID → start server in background
+ *   3. Health check + version mismatch detection
+ *   4. Send command via HTTP POST
+ *   5. Print response to stdout (or stderr for errors)
+ */
+export declare function resolveServerScript(env?: Record<string, string | undefined>, metaDir?: string, execPath?: string): string;
+export declare function resolveNodeServerScript(metaDir?: string, execPath?: string): string | null;

package/dist/features/browser-daemon/commands.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Command registry — single source of truth for all browse commands.
+ * Zero side effects. Safe to import from build scripts and tests.
+ */
+export declare const READ_COMMANDS: Set<string>;
+export declare const WRITE_COMMANDS: Set<string>;
+export declare const META_COMMANDS: Set<string>;
+export declare const ALL_COMMANDS: Set<string>;
+export declare const COMMAND_DESCRIPTIONS: Record<string, {
+    category: string;
+    description: string;
+    usage?: string;
+}>;

package/dist/features/browser-daemon/config.d.ts

@@ -0,0 +1,6 @@
+import type { BrowseConfig } from './types.ts';
+export declare function getGitRoot(): string | null;
+export declare function resolveConfig(env?: Record<string, string | undefined>): BrowseConfig;
+export declare function ensureBrowserStateDir(config: BrowseConfig): void;
+export declare function getRemoteSlug(): string;
+export declare function readVersionHash(execPath?: string): string | null;

package/dist/features/browser-daemon/cookie-import-browser.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Chromium browser cookie import — read and decrypt cookies from real browsers
+ *
+ * Supports macOS Chromium-based browsers: Comet, Chrome, Arc, Brave, Edge.
+ * Pure logic module — no Playwright dependency, no HTTP concerns.
+ *
+ * Decryption pipeline (Chromium macOS "v10" format):
+ *
+ *   ┌──────────────────────────────────────────────────────────────────┐
+ *   │ 1. Keychain: `security find-generic-password -s "<svc>" -w`     │
+ *   │    → base64 password string                                     │
+ *   │                                                                  │
+ *   │ 2. Key derivation:                                               │
+ *   │    PBKDF2(password, salt="saltysalt", iter=1003, len=16, sha1)  │
+ *   │    → 16-byte AES key                                            │
+ *   │                                                                  │
+ *   │ 3. For each cookie with encrypted_value starting with "v10":    │
+ *   │    - Ciphertext = encrypted_value[3:]                           │
+ *   │    - IV = 16 bytes of 0x20 (space character)                    │
+ *   │    - Plaintext = AES-128-CBC-decrypt(key, iv, ciphertext)       │
+ *   │    - Remove PKCS7 padding                                       │
+ *   │    - Skip first 32 bytes (HMAC-SHA256 authentication tag)       │
+ *   │    - Remaining bytes = cookie value (UTF-8)                     │
+ *   │                                                                  │
+ *   │ 4. If encrypted_value is empty but `value` field is set,        │
+ *   │    use value directly (unencrypted cookie)                      │
+ *   │                                                                  │
+ *   │ 5. Chromium epoch: microseconds since 1601-01-01                │
+ *   │    Unix seconds = (epoch - 11644473600000000) / 1000000         │
+ *   │                                                                  │
+ *   │ 6. sameSite: 0→"None", 1→"Lax", 2→"Strict", else→"Lax"        │
+ *   └──────────────────────────────────────────────────────────────────┘
+ */
+export interface BrowserInfo {
+    name: string;
+    dataDir: string;
+    keychainService: string;
+    aliases: string[];
+}
+export interface DomainEntry {
+    domain: string;
+    count: number;
+}
+export interface ImportResult {
+    cookies: PlaywrightCookie[];
+    count: number;
+    failed: number;
+    domainCounts: Record<string, number>;
+}
+export interface PlaywrightCookie {
+    name: string;
+    value: string;
+    domain: string;
+    path: string;
+    expires: number;
+    secure: boolean;
+    httpOnly: boolean;
+    sameSite: 'Strict' | 'Lax' | 'None';
+}
+export declare class CookieImportError extends Error {
+    code: string;
+    action?: "retry" | undefined;
+    constructor(message: string, code: string, action?: "retry" | undefined);
+}
+export declare function findInstalledBrowsers(): BrowserInfo[];
+export declare function listDomains(browserName: string, profile?: string): {
+    domains: DomainEntry[];
+    browser: string;
+};
+export declare function importCookies(browserName: string, domains: string[], profile?: string): Promise<ImportResult>;

package/dist/features/browser-daemon/cookie-picker-routes.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Cookie picker route handler — HTTP + Playwright glue
+ *
+ * Handles all /cookie-picker/* routes. Imports from cookie-import-browser.ts
+ * (decryption) and cookie-picker-ui.ts (HTML generation).
+ *
+ * Routes (no auth — localhost-only, accepted risk):
+ *   GET  /cookie-picker              → serves the picker HTML page
+ *   GET  /cookie-picker/browsers     → list installed browsers
+ *   GET  /cookie-picker/domains      → list domains + counts for a browser
+ *   POST /cookie-picker/import       → decrypt + import cookies to Playwright
+ *   POST /cookie-picker/remove       → clear cookies for domains
+ *   GET  /cookie-picker/imported     → currently imported domains + counts
+ */
+import type { BrowserManager } from './browser-manager.ts';
+export declare function handleCookiePickerRoute(url: URL, req: Request, bm: BrowserManager): Promise<Response>;

package/dist/features/browser-daemon/cookie-picker-ui.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Cookie picker UI — self-contained HTML page
+ *
+ * Dark theme, two-panel layout, vanilla HTML/CSS/JS.
+ * Left: source browser domains with search + import buttons.
+ * Right: imported domains with trash buttons.
+ * No cookie values exposed anywhere.
+ */
+export declare function getCookiePickerHTML(serverPort: number): string;

package/dist/features/browser-daemon/find-browse.d.ts

@@ -0,0 +1,7 @@
+/**
+ * find-browse — locate the @nntoan/gstack browse binary.
+ *
+ * Compiled to browse/dist/find-browse (standalone binary, no bun runtime needed).
+ * Outputs the absolute path to the browse binary on stdout, or exits 1 if not found.
+ */
+export declare function locateBinary(): string | null;