@zeph-to/cli 1.12.0

package/dist/installer.js

@@ -0,0 +1,464 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleInstall = exports.filterAgentsByIds = exports.shouldTriggerLogin = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const readline_1 = require("readline");
+const zeph_hook_js_1 = require("./zeph-hook.js");
+const config_js_1 = require("./config.js");
+const login_js_1 = require("./login.js");
+const agents_js_1 = require("./agents.js");
+const templates_js_1 = require("./templates.js");
+const HOME = (0, os_1.homedir)();
+// ── Helpers ──────────────────────────────────────────────────────
+const ok = (msg) => console.log(`    + ${msg}`);
+const fail = (msg) => console.log(`    - ${msg}`);
+/**
+ * True when install should auto-open browser login (ADR 0002): interactive
+ * context with no existing credential (--key/env/config all absent).
+ */
+const shouldTriggerLogin = (nonInteractive, currentKey) => !nonInteractive && !currentKey;
+exports.shouldTriggerLogin = shouldTriggerLogin;
+const promptInput = (question) => {
+    const rl = (0, readline_1.createInterface)({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+};
+const writeFile = (filePath, content) => {
+    (0, fs_1.mkdirSync)((0, path_1.dirname)(filePath), { recursive: true });
+    (0, fs_1.writeFileSync)(filePath, content + '\n');
+};
+const mergeJsonFile = (filePath, patch) => {
+    let data = {};
+    try {
+        data = JSON.parse((0, fs_1.readFileSync)(filePath, 'utf-8'));
+    }
+    catch { /* new file */ }
+    const merged = { ...data, ...patch };
+    writeFile(filePath, JSON.stringify(merged, null, 2));
+};
+/**
+ * Write a Zeph rule into a SHARED agent rule file (Windsurf global_rules.md,
+ * Gemini GEMINI.md, Codex AGENTS.md) without clobbering the user's own
+ * content. The rule lands inside <!-- ZEPH:START/END --> markers; a re-run
+ * replaces just that block.
+ */
+const writeManagedRule = (filePath, rule) => {
+    let existing = '';
+    try {
+        existing = (0, fs_1.readFileSync)(filePath, 'utf-8');
+    }
+    catch { /* new file */ }
+    (0, fs_1.mkdirSync)((0, path_1.dirname)(filePath), { recursive: true });
+    (0, fs_1.writeFileSync)(filePath, (0, templates_js_1.upsertManagedBlock)(existing, rule));
+};
+/**
+ * Add a `read:` entry to ~/.aider.conf.yml so Aider always loads the Zeph
+ * conventions file. Idempotent — skips if the path is already referenced.
+ * Aider's config is YAML; we do a minimal text-level append to avoid
+ * pulling in a YAML dependency (the SDK is zero-dep by design).
+ */
+const addAiderReadDirective = (confPath, conventionsPath) => {
+    let conf = '';
+    try {
+        conf = (0, fs_1.readFileSync)(confPath, 'utf-8');
+    }
+    catch { /* new file */ }
+    if (conf.includes(conventionsPath))
+        return; // already wired up
+    const marker = '# Added by Zeph';
+    const line = `${marker}\nread: ${conventionsPath}\n`;
+    const base = conf.replace(/\n*$/, '');
+    (0, fs_1.mkdirSync)((0, path_1.dirname)(confPath), { recursive: true });
+    (0, fs_1.writeFileSync)(confPath, (base ? `${base}\n\n` : '') + line);
+};
+// ── Per-Agent Installers ─────────────────────────────────────────
+const injectMcpJson = (filePath) => {
+    let data = {};
+    try {
+        data = JSON.parse((0, fs_1.readFileSync)(filePath, 'utf-8'));
+    }
+    catch { /* new file */ }
+    if (!data.mcpServers)
+        data.mcpServers = {};
+    // Pass through env explicitly so the MCP server doesn't have to rely on
+    // process-env inheritance (which behaves differently per IDE — Cursor and
+    // Windsurf spawn the MCP from a graphical context that may not inherit
+    // shell env). Mirrors plugin/.mcp.json.
+    data.mcpServers.zeph = {
+        command: 'npx',
+        args: ['-y', '@zeph-to/mcp-server'],
+        env: { ZEPH_API_KEY: '${ZEPH_API_KEY}' },
+    };
+    (0, fs_1.mkdirSync)((0, path_1.dirname)(filePath), { recursive: true });
+    (0, fs_1.writeFileSync)(filePath, JSON.stringify(data, null, 2) + '\n');
+};
+const installClaude = () => {
+    try {
+        (0, child_process_1.execSync)('claude plugin marketplace add zeph-to/plugin', { stdio: 'pipe' });
+        (0, child_process_1.execSync)('claude plugin install zeph@zeph', { stdio: 'pipe' });
+        ok('Plugin installed');
+    }
+    catch {
+        fail('Plugin install failed. Manual:');
+        console.log('      claude plugin marketplace add zeph-to/plugin');
+        console.log('      claude plugin install zeph@zeph');
+    }
+};
+const installCursor = () => {
+    try {
+        injectMcpJson((0, path_1.join)(HOME, '.cursor', 'mcp.json'));
+        ok('MCP server added');
+    }
+    catch {
+        fail('MCP injection failed. Manual: add zeph to ~/.cursor/mcp.json');
+    }
+    try {
+        writeFile((0, path_1.join)(HOME, '.cursor', 'hooks.json'), templates_js_1.CURSOR_HOOKS);
+        ok('Stop hook added');
+    }
+    catch {
+        fail('Hook install failed');
+    }
+    try {
+        writeFile((0, path_1.join)(HOME, '.cursor', 'rules', 'zeph.mdc'), templates_js_1.CURSOR_RULE);
+        ok('Rule file added');
+    }
+    catch {
+        fail('Rule install failed');
+    }
+};
+const installWindsurf = () => {
+    try {
+        injectMcpJson((0, path_1.join)(HOME, '.codeium', 'windsurf', 'mcp_config.json'));
+        ok('MCP server added');
+    }
+    catch {
+        fail('MCP injection failed. Manual: add zeph to windsurf mcp_config.json');
+    }
+    try {
+        writeFile((0, path_1.join)(HOME, '.codeium', 'windsurf', 'hooks.json'), templates_js_1.WINDSURF_HOOKS);
+        ok('Response hook added');
+    }
+    catch {
+        fail('Hook install failed');
+    }
+    try {
+        // Windsurf reads ~/.codeium/windsurf/memories/global_rules.md as always-on
+        // global rules. Managed-block append preserves the user's own rules.
+        writeManagedRule((0, path_1.join)(HOME, '.codeium', 'windsurf', 'memories', 'global_rules.md'), templates_js_1.WINDSURF_RULE);
+        ok('Rules added to global_rules.md');
+    }
+    catch {
+        fail('Rule install failed. Manual: add zeph rules to ~/.codeium/windsurf/memories/global_rules.md');
+    }
+};
+const installGemini = () => {
+    try {
+        (0, child_process_1.execSync)('gemini mcp add zeph -- npx -y @zeph-to/mcp-server', { stdio: 'pipe' });
+        ok('MCP server added');
+    }
+    catch {
+        fail('MCP add failed. Manual: gemini mcp add zeph -- npx -y @zeph-to/mcp-server');
+    }
+    try {
+        mergeJsonFile((0, path_1.join)(HOME, '.gemini', 'settings.json'), templates_js_1.GEMINI_HOOKS);
+        ok('AfterAgent hook added');
+    }
+    catch {
+        fail('Hook install failed');
+    }
+    try {
+        // Gemini CLI loads ~/.gemini/GEMINI.md as global context every prompt.
+        writeManagedRule((0, path_1.join)(HOME, '.gemini', 'GEMINI.md'), templates_js_1.GEMINI_RULE);
+        ok('Rules added to GEMINI.md');
+    }
+    catch {
+        fail('Rule install failed. Manual: add zeph rules to ~/.gemini/GEMINI.md');
+    }
+};
+const installCodex = () => {
+    try {
+        writeFile((0, path_1.join)(HOME, '.codex', 'hooks.json'), templates_js_1.CODEX_HOOKS);
+        ok('Stop hook added');
+    }
+    catch {
+        fail('Hook install failed. Manual: add zeph to ~/.codex/hooks.json');
+    }
+    try {
+        // Codex CLI loads ~/.codex/AGENTS.md as global instructions.
+        writeManagedRule((0, path_1.join)(HOME, '.codex', 'AGENTS.md'), templates_js_1.CODEX_RULE);
+        ok('Rules added to AGENTS.md');
+    }
+    catch {
+        fail('Rule install failed. Manual: add zeph rules to ~/.codex/AGENTS.md');
+    }
+};
+const installCopilot = () => {
+    try {
+        writeFile((0, path_1.join)(HOME, '.copilot', 'hooks', 'zeph.json'), templates_js_1.COPILOT_HOOKS);
+        ok('Session end hook added');
+    }
+    catch {
+        fail('Hook install failed. Manual: add zeph to ~/.copilot/hooks/');
+    }
+    try {
+        // Copilot CLI loads ~/.copilot/instructions/*.instructions.md globally.
+        // A dedicated file means no merge needed — overwrite is safe.
+        writeFile((0, path_1.join)(HOME, '.copilot', 'instructions', 'zeph.instructions.md'), templates_js_1.COPILOT_RULE);
+        ok('Rule file added');
+    }
+    catch {
+        fail('Rule install failed. Manual: add zeph rules to ~/.copilot/instructions/');
+    }
+};
+const installCline = () => {
+    try {
+        writeFile((0, path_1.join)(HOME, '.cline', 'rules', 'zeph.md'), templates_js_1.CLINE_RULE);
+        ok('Rule file added');
+    }
+    catch {
+        fail('Rule install failed. Manual: add zeph to ~/.cline/rules/');
+    }
+};
+const installAider = () => {
+    // Aider has no hooks; rules reach it via a conventions file loaded by the
+    // `read:` directive in ~/.aider.conf.yml. We keep the conventions file in
+    // ~/.zeph/ (our own dir — no conflict) and just wire the read directive.
+    const conventionsPath = (0, path_1.join)(HOME, '.zeph', 'aider-conventions.md');
+    try {
+        writeFile(conventionsPath, templates_js_1.AIDER_RULE);
+        ok('Conventions file added');
+    }
+    catch {
+        fail('Conventions install failed. Manual: save zeph rules somewhere readable');
+        return;
+    }
+    try {
+        addAiderReadDirective((0, path_1.join)(HOME, '.aider.conf.yml'), conventionsPath);
+        ok('read: directive added to ~/.aider.conf.yml');
+    }
+    catch {
+        fail(`Config wiring failed. Manual: add "read: ${conventionsPath}" to ~/.aider.conf.yml`);
+    }
+};
+const AGENT_INSTALLERS = {
+    claude: installClaude,
+    cursor: installCursor,
+    windsurf: installWindsurf,
+    gemini: installGemini,
+    codex: installCodex,
+    copilot: installCopilot,
+    cline: installCline,
+    aider: installAider,
+};
+// One-line summary of what each agent's installer does — shown in the
+// interactive plan before anything is written.
+const AGENT_PLAN_LABELS = {
+    claude: 'Claude Code — install plugin',
+    cursor: 'Cursor — MCP + hooks + rules',
+    windsurf: 'Windsurf — MCP + hooks + rules',
+    gemini: 'Gemini CLI — MCP + hooks + rules',
+    codex: 'Codex CLI — hooks + rules',
+    copilot: 'Copilot CLI — hooks + rules',
+    cline: 'Cline — rules',
+    aider: 'Aider — conventions',
+};
+// ── Agent selection ──────────────────────────────────────────────
+/**
+ * Interactive agent picker — an @inquirer/prompts checkbox (arrow keys
+ * to move, space to toggle, enter to confirm). Every agent starts
+ * checked, so a bare Enter installs for all. Returns the chosen Agent[].
+ *
+ * Dynamic import keeps @inquirer/prompts (ESM) loadable from this
+ * CommonJS build, and means the dependency is only touched on the
+ * interactive path — `notify` / `list` / scripted `install --only`
+ * never load it.
+ */
+const pickAgentsInteractive = async (detected) => {
+    const { checkbox } = await import('@inquirer/prompts');
+    const picked = await checkbox({
+        message: 'Install Zeph for which agents? (space to toggle, enter to confirm)',
+        choices: detected.map((agent) => ({
+            name: AGENT_PLAN_LABELS[agent.id] ?? agent.name,
+            value: agent.id,
+            checked: true,
+        })),
+        loop: false,
+    });
+    return detected.filter((a) => picked.includes(a.id));
+};
+/**
+ * Resolve agents from a non-interactive `--only cursor,gemini` flag.
+ * Matches on agent id; unknown ids are silently dropped. Exported for
+ * unit testing.
+ */
+const filterAgentsByIds = (detected, only) => {
+    const ids = new Set(only.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean));
+    return detected.filter((a) => ids.has(a.id));
+};
+exports.filterAgentsByIds = filterAgentsByIds;
+// ── Test Connection ──────────────────────────────────────────────
+const testConnection = async (apiKey, baseUrl) => {
+    try {
+        const hook = new zeph_hook_js_1.ZephHook({ apiKey, ...(baseUrl && { baseUrl }) });
+        const result = await hook.notify({
+            title: 'Zeph Setup',
+            body: `Connected successfully (v${config_js_1.VERSION})`,
+        });
+        ok(`Test push sent: ${result.pushId}`);
+        return true;
+    }
+    catch (err) {
+        fail(`Test failed: ${err instanceof Error ? err.message : 'Unknown error'}`);
+        return false;
+    }
+};
+/** Interactive path when a credential already exists: prompt to keep/replace. */
+const promptExistingCredentials = async (currentKey, existing) => {
+    if (currentKey)
+        console.log(`  Current API Key: ${currentKey.slice(0, 12)}...`);
+    const keyInput = await promptInput(currentKey ? '  New API Key (Enter to keep): ' : '  API Key (from app > Settings > API Keys): ');
+    const currentHook = (0, config_js_1.resolvedEnv)('ZEPH_HOOK_ID') || existing.hookId;
+    if (currentHook)
+        console.log(`  Current Hook ID: ${currentHook}`);
+    const hookInput = await promptInput(currentHook ? '  New Hook ID (Enter to keep, "none" to remove): ' : '  Hook ID (optional, for prompt/input): ');
+    return {
+        apiKey: keyInput || currentKey,
+        hookId: hookInput === 'none' ? undefined : (hookInput || currentHook),
+        baseUrl: existing.baseUrl,
+    };
+};
+/**
+ * Resolve API key + hook for install. Priority: --key/env/config (non-interactive
+ * or "keep existing") → brand-new interactive opens browser login (ADR 0002),
+ * falling back to manual paste when headless. wsUrl/deviceId from a login are
+ * persisted by runLoginFlow and re-read at config-save time.
+ */
+const collectCredentials = async (args, installArgs, nonInteractive, existing) => {
+    if (nonInteractive) {
+        return {
+            apiKey: installArgs.key || (0, config_js_1.resolvedEnv)('ZEPH_API_KEY') || existing.apiKey,
+            hookId: installArgs.hook === 'none' ? undefined : (installArgs.hook || (0, config_js_1.resolvedEnv)('ZEPH_HOOK_ID') || existing.hookId),
+            baseUrl: installArgs['base-url'] || (0, config_js_1.resolvedEnv)('ZEPH_BASE_URL') || existing.baseUrl,
+        };
+    }
+    console.log('');
+    const currentKey = (0, config_js_1.resolvedEnv)('ZEPH_API_KEY') || existing.apiKey;
+    if (!(0, exports.shouldTriggerLogin)(nonInteractive, currentKey)) {
+        return promptExistingCredentials(currentKey, existing);
+    }
+    const result = await (0, login_js_1.runLoginFlow)({
+        webUrl: (0, login_js_1.resolveWebUrl)(args['web-url']),
+        timeoutSec: (0, login_js_1.resolveTimeoutSec)(args.timeout),
+    });
+    if (result) {
+        return { apiKey: result.apiKey, hookId: result.hookId, baseUrl: result.baseUrl };
+    }
+    // headless / timeout → manual paste
+    const apiKey = (await promptInput('  API Key (from app > Settings > API Keys): ')) || undefined;
+    const hookInput = await promptInput('  Hook ID (optional, for prompt/input): ');
+    return { apiKey, hookId: hookInput || undefined, baseUrl: existing.baseUrl };
+};
+// ── Main Install Flow ────────────────────────────────────────────
+const handleInstall = async (args) => {
+    const installArgs = {
+        key: args.key,
+        hook: args.hook,
+        'base-url': args['base-url'],
+    };
+    const nonInteractive = !!(installArgs.key || installArgs.hook || installArgs['base-url']);
+    console.log(`\n  Zeph v${config_js_1.VERSION}\n`);
+    // 1. Detect agents
+    console.log('  Detecting agents...');
+    const agents = (0, agents_js_1.detectAgents)();
+    const detected = agents.filter((a) => a.detected);
+    for (const agent of agents) {
+        if (agent.detected) {
+            ok(agent.name);
+        }
+        else {
+            fail(`${agent.name} (not found)`);
+        }
+    }
+    if (detected.length === 0) {
+        console.log('\n  No supported agents found. Config will still be saved.\n');
+    }
+    // 2. Choose which agents to install for — asked up front so the user
+    //    sees the choice before being walked through credential prompts.
+    let selected = detected;
+    const onlyArg = args.only?.trim();
+    if (detected.length > 0) {
+        if (onlyArg) {
+            // Non-interactive or scripted: --only cursor,gemini
+            selected = (0, exports.filterAgentsByIds)(detected, onlyArg);
+            console.log(`\n  --only ${onlyArg} → ${selected.map((a) => a.name).join(', ') || '(no match)'}`);
+        }
+        else if (nonInteractive) {
+            // Scripted run with no --only: keep the all-detected default
+            selected = detected;
+        }
+        else {
+            try {
+                selected = await pickAgentsInteractive(detected);
+            }
+            catch {
+                // Ctrl-C in the picker (or no TTY) — treat as a clean cancel.
+                console.log('\n  Cancelled.\n');
+                return 0;
+            }
+        }
+    }
+    // 3. Collect credentials (browser login auto-triggers for brand-new installs)
+    const existing = (0, config_js_1.loadConfig)();
+    const { apiKey, hookId, baseUrl } = await collectCredentials(args, installArgs, nonInteractive, existing);
+    if (!apiKey) {
+        console.error('\n  Error: API key is required.\n');
+        return 1;
+    }
+    // 4. Show the resolved plan before touching anything (interactive only).
+    if (!nonInteractive) {
+        console.log('\n  Will do:');
+        console.log(`    - Save config to ${config_js_1.CONFIG_FILE}`);
+        for (const agent of selected) {
+            console.log(`    - ${AGENT_PLAN_LABELS[agent.id] ?? `Install for ${agent.name}`}`);
+        }
+        if (selected.length === 0) {
+            console.log('    (no agents selected — only the config file will be saved)');
+        }
+        console.log('    - Test connection');
+    }
+    // 5. Save config — merge over the latest on-disk config (re-read, since a
+    //    login in step 3 may have written wsUrl/deviceId). hookId set or cleared.
+    console.log('');
+    const config = {
+        ...(0, config_js_1.loadConfig)(),
+        apiKey,
+        ...(baseUrl && { baseUrl }),
+    };
+    if (hookId)
+        config.hookId = hookId;
+    else
+        delete config.hookId;
+    (0, config_js_1.saveConfig)(config);
+    ok(`Config saved to ${config_js_1.CONFIG_FILE}`);
+    // 6. Install for the selected agents only
+    for (const agent of selected) {
+        console.log(`\n  Installing for ${agent.name}...`);
+        const installer = AGENT_INSTALLERS[agent.id];
+        if (installer)
+            installer();
+    }
+    // 7. Test connection
+    console.log('\n  Testing connection...');
+    await testConnection(apiKey, baseUrl);
+    console.log('\n  Done! Restart your agents.\n');
+    return 0;
+};
+exports.handleInstall = handleInstall;

package/dist/listener.d.ts

@@ -0,0 +1,126 @@
+/**
+ * `zeph listener` — resident daemon that watches the user's Zeph feed
+ * over a persistent WebSocket and injects matching messages into a
+ * named tmux session via `tmux send-keys`.
+ *
+ * Solves the MCP polling-window problem: an `zeph_ask` polling cycle
+ * times out (120–600 s) and the CC/Codex session becomes unaddressable
+ * from the phone. The listener stays subscribed indefinitely and can
+ * deliver to any named tmux session at any time.
+ *
+ * Wire format: pushes with `type='agent.command'` carry the tmux
+ * session name in `agentSessionName` and the message in `body`. The
+ * "AI Agent에게 명령" sheet on the phone builds these structured
+ * pushes from the listener-reported session inventory. Other push
+ * types (Stop-hook auto-pushes, zeph_ask responses, channel
+ * broadcasts) are ignored.
+ *
+ * Transport: WebSocket against the Zeph $connect endpoint with
+ * `?apiKey=<key>`. The server fan-out pushes `{ type: 'push.new', data }`
+ * messages as new pushes are created. Reconnects with exponential
+ * backoff on transient failures; gives up on auth failures (4001/4002/4003).
+ */
+type AgentKind = 'claude' | 'codex' | 'gemini';
+interface AgentSession {
+    name: string;
+    attached: boolean;
+    agentKind: AgentKind;
+    agentSessionId?: string | null;
+    project: string;
+    label?: string | null;
+    createdAt?: string;
+    lastActivityAt?: string;
+}
+export declare const checkRateLimit: (session: string, now?: number) => boolean;
+/** Read the foreground command in the named tmux session's active pane. */
+export declare const paneCurrentCommand: (session: string) => string | null;
+/**
+ * Mark the cached socket as no longer trustworthy — call this when a
+ * tmux command fails against the cached path. The next findTmuxSocket()
+ * will redo full discovery (default probe → /var/folders walk → lsof
+ * fallback) instead of returning a stale answer. Without this the
+ * listener wedged at "reported 0 session(s)" forever after a tmux
+ * server restart, even when a new server was live and discoverable.
+ */
+export declare const invalidateTmuxSocketCache: () => void;
+/**
+ * Parse a `zeph-*` tmux session name into `{project, label}`. For
+ * Phase 1 the wrapper only emits `zeph-<project>` (no labels), so the
+ * whole tail becomes the project. When labels land in Phase 2 the
+ * wrapper will sidecar `{project, label}` so the listener doesn't need
+ * to guess from a name that allows dashes in project names.
+ */
+export declare const parseSessionName: (name: string) => {
+    project: string;
+    label: string | null;
+} | null;
+/**
+ * Locate the most recent Claude Code session UUID for the working
+ * directory of a tmux pane. Mirrors `mcp-server/config.ts`'s
+ * detectClaudeSessionId: CC writes per-session jsonl files at
+ * `~/.claude/projects/<projectHash>/<UUID>.jsonl` where the hash is
+ * the cwd with `/` replaced by `-`. Cached for 60s — see
+ * claudeSessionCache.
+ */
+export declare const detectClaudeSessionId: (cwd: string) => string | null;
+export interface CollectResult {
+    sessions: AgentSession[];
+    /** Diagnostic notes per rejected session — surfaced under `--verbose`. */
+    rejected: Array<{
+        name: string;
+        reason: string;
+    }>;
+}
+/**
+ * Inventory pass that also records *why* each `zeph-*` session was
+ * skipped. The verbose log uses the rejection notes to explain empty
+ * pickers (most common cause: tmux pane lost its start_command after a
+ * re-attach, and the current command is `node` rather than `claude`).
+ */
+export declare const collectSessionsVerbose: () => CollectResult;
+/**
+ * Snapshot the live `zeph-*` tmux sessions on this machine, enriched
+ * with the running agent kind, CC session UUID (claude only), project,
+ * and tmux activity timestamps. Returns [] when tmux is unreachable
+ * or no agent sessions exist. Sessions whose pane is at a shell or
+ * running something other than claude/codex/gemini are filtered out
+ * — the phone can't usefully address them.
+ */
+export declare const collectSessions: () => AgentSession[];
+interface PushItem {
+    pushId: string;
+    type?: string;
+    body?: string;
+    title?: string;
+    createdAt?: string;
+    isEncrypted?: boolean;
+    /** Set when type='agent.command' — tmux session name to inject into. */
+    agentSessionName?: string;
+}
+interface HandlePushDeps {
+    paneCommand?: (session: string) => string | null;
+    inject?: (session: string, text: string) => boolean;
+    rateLimit?: (session: string) => boolean;
+    now?: () => number;
+}
+/**
+ * Process one push. Returns true when an injection actually fired.
+ * Exported for unit testing with mocked deps.
+ *
+ * Only acts on `type='agent.command'` pushes carrying both an
+ * `agentSessionName` (tmux session to inject into) and a non-empty
+ * `body`. Everything else (Stop-hook auto-pushes, zeph_ask responses,
+ * encrypted pushes, normal text/link/file notifications) is ignored.
+ */
+export declare const handlePush: (push: PushItem, deps?: HandlePushDeps) => boolean;
+/**
+ * Stable per-host device id for the listener. We hash the OS hostname so
+ * the same machine reuses the same DeviceRecord across listener restarts
+ * (otherwise the phone's session inventory grows a new ghost device every
+ * time `zeph listener` rebinds). `dev_listener_<sha8(hostname)>` keeps it
+ * human-recognisable in dev logs without leaking the raw hostname.
+ */
+export declare const computeListenerDeviceId: (host?: string) => string;
+export declare const handleListener: (args: Record<string, string | boolean>) => Promise<number>;
+export {};
+//# sourceMappingURL=listener.d.ts.map

package/dist/listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listener.d.ts","sourceRoot":"","sources":["../src/listener.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAmCH,KAAK,SAAS,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;AAG/C,UAAU,YAAY;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,SAAS,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;CAC3B;AA2BD,eAAO,MAAM,cAAc,GAAI,SAAS,MAAM,EAAE,MAAK,MAAmB,KAAG,OAgB1E,CAAC;AAEF,2EAA2E;AAC3E,eAAO,MAAM,kBAAkB,GAAI,SAAS,MAAM,KAAG,MAAM,GAAG,IAO7D,CAAC;AAiDF;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,QAAO,IAG5C,CAAC;AA8NF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,KAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAAG,IAK3F,CAAC;AAuCF;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,GAAI,KAAK,MAAM,KAAG,MAAM,GAAG,IAiB5D,CAAC;AAkFF,MAAM,WAAW,aAAa;IAC1B,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,0EAA0E;IAC1E,QAAQ,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACrD;AAED;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,QAAO,aA+DzC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,QAAO,YAAY,EAAuC,CAAC;AAIvF,UAAU,QAAQ;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,wEAAwE;IACxE,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,UAAU,cAAc;IACpB,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IACjD,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IACpD,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IACzC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACtB;AAgCD;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,GACnB,MAAM,QAAQ,EACd,OAAM,cAAmB,KAC1B,OAQF,CAAC;AA2BF;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,GAAI,OAAM,MAAmB,KAAG,MAGnE,CAAC;AA8NF,eAAO,MAAM,cAAc,GAAU,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,KAAG,OAAO,CAAC,MAAM,CAyF3F,CAAC"}