@zeph-to/cli 1.12.0

package/dist/uninstall.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleUninstall = 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 agents_js_1 = require("./agents.js");
+const templates_js_1 = require("./templates.js");
+const config_js_1 = require("./config.js");
+const HOME = (0, os_1.homedir)();
+const ok = (msg) => console.log(`    + ${msg}`);
+const skip = (msg) => console.log(`    - ${msg}`);
+// ── Removal primitives ───────────────────────────────────────────
+// Each primitive returns a short human description of what it did (or
+// would do, in dry-run), or null when there was nothing to remove.
+/** Past/conditional verb so dry-run output reads honestly. */
+const verb = (dry) => (dry ? 'would remove' : 'removed');
+/** Delete a file Zeph fully owns. */
+const rmFile = (filePath, dry) => {
+    if (!(0, fs_1.existsSync)(filePath))
+        return null;
+    if (!dry)
+        (0, fs_1.rmSync)(filePath, { force: true });
+    return `${verb(dry)} ${filePath}`;
+};
+/** Remove just the `zeph` entry from an mcpServers JSON file. */
+const rmMcpEntry = (filePath, dry) => {
+    if (!(0, fs_1.existsSync)(filePath))
+        return null;
+    let data;
+    try {
+        data = JSON.parse((0, fs_1.readFileSync)(filePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+    const servers = data.mcpServers;
+    if (!servers || !('zeph' in servers))
+        return null;
+    if (!dry) {
+        delete servers.zeph;
+        (0, fs_1.writeFileSync)(filePath, JSON.stringify(data, null, 2) + '\n');
+    }
+    return `${verb(dry)} zeph from ${filePath}`;
+};
+/** Strip the <!-- ZEPH:START/END --> block from a shared rule file. */
+const stripManagedRule = (filePath, dry) => {
+    if (!(0, fs_1.existsSync)(filePath))
+        return null;
+    const existing = (0, fs_1.readFileSync)(filePath, 'utf-8');
+    const stripped = (0, templates_js_1.removeManagedBlock)(existing);
+    if (stripped === existing)
+        return null; // no Zeph block present
+    if (!dry) {
+        if (stripped.trim() === '') {
+            (0, fs_1.rmSync)(filePath, { force: true }); // file was ours alone
+        }
+        else {
+            (0, fs_1.writeFileSync)(filePath, stripped);
+        }
+    }
+    return `${verb(dry)} Zeph block from ${filePath}`;
+};
+/** Drop the Zeph `read:` directive from ~/.aider.conf.yml. */
+const rmAiderReadDirective = (confPath, dry) => {
+    if (!(0, fs_1.existsSync)(confPath))
+        return null;
+    const conf = (0, fs_1.readFileSync)(confPath, 'utf-8');
+    if (!conf.includes('# Added by Zeph'))
+        return null;
+    // Drop the "# Added by Zeph" line and the "read:" line that follows it.
+    const lines = conf.split('\n');
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim() === '# Added by Zeph') {
+            if (lines[i + 1]?.trimStart().startsWith('read:'))
+                i++; // skip read: too
+            continue;
+        }
+        out.push(lines[i]);
+    }
+    if (!dry)
+        (0, fs_1.writeFileSync)(confPath, out.join('\n').replace(/\n{3,}/g, '\n\n'));
+    return `${verb(dry)} Zeph read: directive from ${confPath}`;
+};
+/** Remove just the zeph-notify entry from Gemini's settings.json. */
+const rmGeminiHook = (filePath, dry) => {
+    if (!(0, fs_1.existsSync)(filePath))
+        return null;
+    let data;
+    try {
+        data = JSON.parse((0, fs_1.readFileSync)(filePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+    const hooks = data.hooks;
+    const afterAgent = hooks?.AfterAgent;
+    if (!Array.isArray(afterAgent))
+        return null;
+    const kept = afterAgent.filter((entry) => !(entry.hooks ?? []).some((h) => h.name === 'zeph-notify'));
+    if (kept.length === afterAgent.length)
+        return null; // nothing of ours
+    if (!dry) {
+        if (kept.length === 0) {
+            delete hooks.AfterAgent;
+        }
+        else {
+            hooks.AfterAgent = kept;
+        }
+        (0, fs_1.writeFileSync)(filePath, JSON.stringify(data, null, 2) + '\n');
+    }
+    return `${verb(dry)} zeph-notify hook from ${filePath}`;
+};
+const runSteps = (steps) => {
+    let did = false;
+    for (const step of steps) {
+        const result = step();
+        if (result) {
+            ok(result);
+            did = true;
+        }
+    }
+    if (!did)
+        skip('nothing to remove');
+};
+const AGENT_UNINSTALLERS = {
+    claude: (dry) => {
+        if (dry) {
+            skip('would run: claude plugin uninstall zeph@zeph');
+            return;
+        }
+        try {
+            (0, child_process_1.execSync)('claude plugin uninstall zeph@zeph', { stdio: 'pipe' });
+            ok('plugin uninstalled');
+        }
+        catch {
+            skip('plugin not installed (or claude CLI unavailable)');
+        }
+    },
+    cursor: (dry) => runSteps([
+        () => rmMcpEntry((0, path_1.join)(HOME, '.cursor', 'mcp.json'), dry),
+        () => rmFile((0, path_1.join)(HOME, '.cursor', 'hooks.json'), dry),
+        () => rmFile((0, path_1.join)(HOME, '.cursor', 'rules', 'zeph.mdc'), dry),
+    ]),
+    windsurf: (dry) => runSteps([
+        () => rmMcpEntry((0, path_1.join)(HOME, '.codeium', 'windsurf', 'mcp_config.json'), dry),
+        () => rmFile((0, path_1.join)(HOME, '.codeium', 'windsurf', 'hooks.json'), dry),
+        () => stripManagedRule((0, path_1.join)(HOME, '.codeium', 'windsurf', 'memories', 'global_rules.md'), dry),
+    ]),
+    gemini: (dry) => {
+        if (!dry) {
+            try {
+                (0, child_process_1.execSync)('gemini mcp remove zeph', { stdio: 'pipe' });
+                ok('MCP server removed');
+            }
+            catch {
+                skip('gemini MCP entry not found');
+            }
+        }
+        else {
+            skip('would run: gemini mcp remove zeph');
+        }
+        runSteps([
+            () => rmGeminiHook((0, path_1.join)(HOME, '.gemini', 'settings.json'), dry),
+            () => stripManagedRule((0, path_1.join)(HOME, '.gemini', 'GEMINI.md'), dry),
+        ]);
+    },
+    codex: (dry) => runSteps([
+        () => rmFile((0, path_1.join)(HOME, '.codex', 'hooks.json'), dry),
+        () => stripManagedRule((0, path_1.join)(HOME, '.codex', 'AGENTS.md'), dry),
+    ]),
+    copilot: (dry) => runSteps([
+        () => rmFile((0, path_1.join)(HOME, '.copilot', 'hooks', 'zeph.json'), dry),
+        () => rmFile((0, path_1.join)(HOME, '.copilot', 'instructions', 'zeph.instructions.md'), dry),
+    ]),
+    cline: (dry) => runSteps([
+        () => rmFile((0, path_1.join)(HOME, '.cline', 'rules', 'zeph.md'), dry),
+    ]),
+    aider: (dry) => runSteps([
+        () => rmFile((0, path_1.join)(HOME, '.zeph', 'aider-conventions.md'), dry),
+        () => rmAiderReadDirective((0, path_1.join)(HOME, '.aider.conf.yml'), dry),
+    ]),
+};
+// ── Entry point ──────────────────────────────────────────────────
+const handleUninstall = async (args) => {
+    const dry = args['dry-run'] === true;
+    const purge = args.purge === true;
+    console.log(`\n  Zeph uninstall${dry ? ' (dry-run)' : ''} — v${config_js_1.VERSION}\n`);
+    const detected = (0, agents_js_1.detectAgents)().filter((a) => a.detected);
+    if (detected.length === 0) {
+        console.log('  No supported agents detected.\n');
+    }
+    for (const agent of detected) {
+        console.log(`  ${agent.name}:`);
+        AGENT_UNINSTALLERS[agent.id]?.(dry);
+    }
+    // ~/.zeph/config.json holds the API key — kept by default so a
+    // re-install doesn't need the key re-entered. --purge removes it.
+    console.log('\n  Config:');
+    if (purge) {
+        const removed = rmFile(config_js_1.CONFIG_FILE, dry);
+        if (removed)
+            ok(removed);
+        else
+            skip('no config file');
+    }
+    else {
+        skip(`kept ${config_js_1.CONFIG_FILE} (pass --purge to remove)`);
+    }
+    console.log(dry
+        ? '\n  Dry-run complete — nothing was changed.\n'
+        : '\n  Uninstall complete. Restart your agents.\n');
+    return 0;
+};
+exports.handleUninstall = handleUninstall;

package/dist/verify.d.ts

@@ -0,0 +1,2 @@
+export declare const handleVerify: (args: Record<string, string | boolean>) => Promise<number>;
+//# sourceMappingURL=verify.d.ts.map

package/dist/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../src/verify.ts"],"names":[],"mappings":"AA0CA,eAAO,MAAM,YAAY,GAAU,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,KAAG,OAAO,CAAC,MAAM,CAwEzF,CAAC"}

package/dist/verify.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleVerify = void 0;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const agents_js_1 = require("./agents.js");
+const config_js_1 = require("./config.js");
+const zeph_hook_js_1 = require("./zeph-hook.js");
+const HOME = (0, os_1.homedir)();
+const pass = (msg) => console.log(`    ✓ ${msg}`);
+const warn = (msg) => console.log(`    ! ${msg}`);
+const failMsg = (msg) => console.log(`    ✗ ${msg}`);
+/** Does a shared rule file contain the Zeph managed block? */
+const hasManagedBlock = (filePath) => {
+    try {
+        return (0, fs_1.readFileSync)(filePath, 'utf-8').includes('ZEPH:START');
+    }
+    catch {
+        return false;
+    }
+};
+// Per-agent: report whether the rule artifact Zeph installs is present.
+const AGENT_RULE_PRESENT = {
+    claude: () => {
+        try {
+            return /zeph/.test((0, fs_1.readFileSync)((0, path_1.join)(HOME, '.claude.json'), 'utf-8'));
+        }
+        catch {
+            return (0, fs_1.existsSync)((0, path_1.join)(HOME, '.claude', 'plugins'));
+        }
+    },
+    cursor: () => (0, fs_1.existsSync)((0, path_1.join)(HOME, '.cursor', 'rules', 'zeph.mdc')),
+    windsurf: () => hasManagedBlock((0, path_1.join)(HOME, '.codeium', 'windsurf', 'memories', 'global_rules.md')),
+    gemini: () => hasManagedBlock((0, path_1.join)(HOME, '.gemini', 'GEMINI.md')),
+    codex: () => hasManagedBlock((0, path_1.join)(HOME, '.codex', 'AGENTS.md')),
+    copilot: () => (0, fs_1.existsSync)((0, path_1.join)(HOME, '.copilot', 'instructions', 'zeph.instructions.md')),
+    cline: () => (0, fs_1.existsSync)((0, path_1.join)(HOME, '.cline', 'rules', 'zeph.md')),
+    aider: () => (0, fs_1.existsSync)((0, path_1.join)(HOME, '.zeph', 'aider-conventions.md')),
+};
+const handleVerify = async (args) => {
+    const doPing = args.ping === true;
+    const checks = [];
+    const record = (label, state) => {
+        checks.push({ label, state });
+        if (state === 'pass')
+            pass(label);
+        else if (state === 'warn')
+            warn(label);
+        else
+            failMsg(label);
+    };
+    console.log(`\n  Zeph verify — v${config_js_1.VERSION}\n`);
+    // ── Credentials ──────────────────────────────────────────────
+    console.log('  Credentials:');
+    const config = (0, config_js_1.loadConfig)();
+    const apiKey = (0, config_js_1.resolvedEnv)('ZEPH_API_KEY') || config.apiKey;
+    const hookId = (0, config_js_1.resolvedEnv)('ZEPH_HOOK_ID') || config.hookId;
+    record(apiKey ? 'ZEPH_API_KEY is set' : 'ZEPH_API_KEY not set (env or ~/.zeph/config.json)', apiKey ? 'pass' : 'fail');
+    record(hookId
+        ? 'ZEPH_HOOK_ID is set (two-way zeph_ask/prompt/input enabled)'
+        : 'ZEPH_HOOK_ID not set (notify-only — set it for remote control)', hookId ? 'pass' : 'warn');
+    // ── Runtime ──────────────────────────────────────────────────
+    console.log('\n  Runtime:');
+    record((0, agents_js_1.hasCommand)('node') ? 'node available' : 'node not found', (0, agents_js_1.hasCommand)('node') ? 'pass' : 'fail');
+    record((0, agents_js_1.hasCommand)('npx') ? 'npx available (MCP server runs via npx)' : 'npx not found', (0, agents_js_1.hasCommand)('npx') ? 'pass' : 'fail');
+    record((0, agents_js_1.hasCommand)('zeph')
+        ? 'zeph CLI on PATH'
+        : 'zeph CLI not on PATH (hooks fall back to npx — slower first call)', (0, agents_js_1.hasCommand)('zeph') ? 'pass' : 'warn');
+    // ── Per-agent config ─────────────────────────────────────────
+    console.log('\n  Agents:');
+    const detected = (0, agents_js_1.detectAgents)().filter((a) => a.detected);
+    if (detected.length === 0) {
+        warn('no supported agents detected');
+    }
+    for (const agent of detected) {
+        const present = AGENT_RULE_PRESENT[agent.id]?.() ?? false;
+        record(`${agent.name}: ${present ? 'Zeph rules installed' : 'Zeph rules NOT installed — run: zeph install'}`, present ? 'pass' : 'warn');
+    }
+    // ── Optional live API ping ───────────────────────────────────
+    if (doPing) {
+        console.log('\n  API ping:');
+        if (!apiKey) {
+            record('skipped — no API key', 'warn');
+        }
+        else {
+            try {
+                const hook = new zeph_hook_js_1.ZephHook({ apiKey, ...(config.baseUrl && { baseUrl: config.baseUrl }) });
+                await hook.list({ limit: 1 });
+                record('API reachable, key accepted', 'pass');
+            }
+            catch (err) {
+                record(`API call failed: ${err instanceof Error ? err.message : 'unknown'}`, 'fail');
+            }
+        }
+    }
+    // ── Summary ──────────────────────────────────────────────────
+    const fails = checks.filter((c) => c.state === 'fail').length;
+    const warns = checks.filter((c) => c.state === 'warn').length;
+    console.log('');
+    if (fails === 0 && warns === 0) {
+        console.log('  ✓ All checks passed.\n');
+    }
+    else {
+        console.log(`  ${fails} failed, ${warns} warnings.${doPing ? '' : ' (run with --ping to test the API)'}\n`);
+    }
+    return fails === 0 ? 0 : 1;
+};
+exports.handleVerify = handleVerify;

package/dist/wrapper.d.ts

@@ -0,0 +1,26 @@
+/** Resolve a project name for the tmux session: env > git root > cwd basename. */
+export declare const detectProjectName: () => string;
+/** `zeph-<project>` — the canonical tmux session base name. */
+export declare const tmuxSessionName: (project: string) => string;
+/**
+ * Pick a tmux session name that won't steal focus from another live
+ * `zeph cc`. Strategy:
+ *   - If `<base>` doesn't exist → use it (create new).
+ *   - If `<base>` exists but is detached → use it (reattach).
+ *   - If `<base>` exists *and* has a client attached → try `<base>-2`,
+ *     `<base>-3`, … so the new `zeph cc` gets an independent session
+ *     instead of joining the existing one.
+ * Falls back to `<base>` after 20 attempts (shouldn't realistically hit).
+ *
+ * Detection uses `tmux has-session` and `tmux list-clients`; both are
+ * dependency-free against the user's running tmux server.
+ */
+export declare const findAvailableSession: (base: string) => string;
+/**
+ * Launch the agent in a named tmux session (or directly if nested) and
+ * forward its exit code. `extra` is appended to the agent invocation, so
+ * `zeph cc --resume foo` runs `claude --resume foo` inside the session.
+ * Returns when the agent exits.
+ */
+export declare const handleAgentSession: (agent: string, extra?: string[]) => Promise<number>;
+//# sourceMappingURL=wrapper.d.ts.map

package/dist/wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapper.d.ts","sourceRoot":"","sources":["../src/wrapper.ts"],"names":[],"mappings":"AAwBA,kFAAkF;AAClF,eAAO,MAAM,iBAAiB,QAAO,MAapC,CAAC;AAEF,+DAA+D;AAC/D,eAAO,MAAM,eAAe,GAAI,SAAS,MAAM,KAAG,MAA2B,CAAC;AAI9E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,KAAG,MAenD,CAAC;AA6HF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,MAAM,EAAE,QAAO,MAAM,EAAO,KAAG,OAAO,CAAC,MAAM,CAmCtF,CAAC"}

package/dist/wrapper.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAgentSession = exports.findAvailableSession = exports.tmuxSessionName = exports.detectProjectName = void 0;
+/**
+ * `zeph cc` / `zeph codex` / `zeph gemini` — spawn an agent inside a named
+ * tmux session so the resident listener (`zeph listener`) can address it
+ * by session name to inject messages later.
+ *
+ * The tmux session name follows `zeph-<project>` where <project> resolves
+ * from CLAUDE/CURSOR/WINDSURF_PROJECT_DIR → git repo root → cwd basename.
+ * When the wrapper is invoked from inside an existing tmux session
+ * ($TMUX set) it skips the outer tmux to avoid nesting and execs the
+ * agent directly — letting power users keep their own multiplexer setup.
+ */
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+/** First non-empty value among the supported per-agent project dir env vars. */
+const PROJECT_DIR_ENVS = ['CLAUDE_PROJECT_DIR', 'CURSOR_PROJECT_DIR', 'WINDSURF_PROJECT_DIR'];
+const FALLBACK_NAME = 'project';
+/** basename(), with a stable fallback for edge paths like `/`. */
+const safeBasename = (path) => (0, path_1.basename)(path) || FALLBACK_NAME;
+/** Resolve a project name for the tmux session: env > git root > cwd basename. */
+const detectProjectName = () => {
+    for (const key of PROJECT_DIR_ENVS) {
+        const v = process.env[key];
+        if (v)
+            return safeBasename(v.replace(/\/+$/, ''));
+    }
+    try {
+        const root = (0, child_process_1.execFileSync)('git', ['rev-parse', '--show-toplevel'], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        if (root)
+            return safeBasename(root);
+    }
+    catch { /* not a git repo — fall through */ }
+    return safeBasename(process.cwd());
+};
+exports.detectProjectName = detectProjectName;
+/** `zeph-<project>` — the canonical tmux session base name. */
+const tmuxSessionName = (project) => `zeph-${project}`;
+exports.tmuxSessionName = tmuxSessionName;
+const MAX_SUFFIX_ATTEMPTS = 20;
+/**
+ * Pick a tmux session name that won't steal focus from another live
+ * `zeph cc`. Strategy:
+ *   - If `<base>` doesn't exist → use it (create new).
+ *   - If `<base>` exists but is detached → use it (reattach).
+ *   - If `<base>` exists *and* has a client attached → try `<base>-2`,
+ *     `<base>-3`, … so the new `zeph cc` gets an independent session
+ *     instead of joining the existing one.
+ * Falls back to `<base>` after 20 attempts (shouldn't realistically hit).
+ *
+ * Detection uses `tmux has-session` and `tmux list-clients`; both are
+ * dependency-free against the user's running tmux server.
+ */
+const findAvailableSession = (base) => {
+    for (let i = 0; i < MAX_SUFFIX_ATTEMPTS; i++) {
+        const name = i === 0 ? base : `${base}-${i + 1}`;
+        const has = (0, child_process_1.spawnSync)('tmux', ['has-session', '-t', name], {
+            stdio: ['ignore', 'ignore', 'ignore'],
+        });
+        if (has.status !== 0)
+            return name; // doesn't exist — fresh session
+        const clients = (0, child_process_1.spawnSync)('tmux', ['list-clients', '-t', name, '-F', '#{client_tty}'], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const attached = (clients.stdout ?? '').trim().length > 0;
+        if (!attached)
+            return name; // exists but detached — reattach
+    }
+    return base;
+};
+exports.findAvailableSession = findAvailableSession;
+/** POSIX shell-quote so passthrough args survive being joined into a tmux shell-command string. */
+const SHELL_SAFE = /^[\w\-./=:@%+,]+$/;
+const shellQuote = (s) => s.length > 0 && SHELL_SAFE.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`;
+const targetForAgent = (agent, extra) => {
+    // Already inside tmux → no nested session, just run the agent in the
+    // current pane. Nested tmux prefix collisions are confusing and the
+    // listener can't reach a session it didn't name anyway.
+    if (process.env.TMUX) {
+        return { cmd: agent, args: extra };
+    }
+    const base = (0, exports.tmuxSessionName)((0, exports.detectProjectName)());
+    // Auto-suffix when the default name is taken by another attached
+    // session — lets the user keep `zeph cc` workflow simple and still
+    // get independent sessions when opening multiple terminals in the
+    // same project.
+    const session = (0, exports.findAvailableSession)(base);
+    // `tmux new -A`: attach if the named session exists, else create it.
+    // tmux joins trailing argv into a single shell-command, so flags like
+    // `--resume` would be eaten by tmux's own parser. Build one quoted
+    // shell string instead, which tmux passes through verbatim.
+    const shellCmd = [agent, ...extra].map(shellQuote).join(' ');
+    return { cmd: 'tmux', args: ['new', '-A', '-s', session, shellCmd] };
+};
+// ── Background listener auto-start ────────────────────────────────────
+const ZEPH_DIR = (0, path_1.join)((0, os_1.homedir)(), '.zeph');
+const LISTENER_PID_FILE = (0, path_1.join)(ZEPH_DIR, 'listener.pid');
+const LISTENER_LOG_FILE = (0, path_1.join)(ZEPH_DIR, 'listener.log');
+/** True when the PID file points at a still-alive process. */
+const listenerAlive = () => {
+    try {
+        const pid = Number((0, fs_1.readFileSync)(LISTENER_PID_FILE, 'utf-8').trim());
+        if (!Number.isFinite(pid) || pid <= 0)
+            return false;
+        // Signal 0 = existence check; throws when the process is gone.
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Path to the running cli.js entry. wrapper.js sits next to cli.js in
+ * dist/, so __dirname resolves it directly — independent of how the
+ * user invoked us.
+ *
+ * `process.argv[1]` is unreliable here: when `zeph` runs via the
+ * npm-installed bin shim (`/usr/local/bin/zeph` → cli.js via a wrapper
+ * script), argv[1] is the shim path (`.../bin/zeph`), NOT `cli.js`.
+ * That made the original `/cli\\.(js|ts|mjs|cjs)$/` check silently
+ * reject the entry and the autospawn never fired — exactly the bug
+ * the user hit ('원래 싱글톤으로 됐었잖아' — yes, on the local alias
+ * path where argv[1] IS cli.js; the bug only surfaced once the user
+ * switched to the global npm install).
+ *
+ * Fall back to argv[1] only when the __dirname-relative file doesn't
+ * exist (some packaging where dist layout differs).
+ */
+const resolveCliPath = () => {
+    const local = (0, path_1.join)(__dirname, 'cli.js');
+    if ((0, fs_1.existsSync)(local))
+        return local;
+    const entry = process.argv[1];
+    if (entry && /cli\.(js|ts|mjs|cjs)$/.test(entry))
+        return entry;
+    return null;
+};
+/**
+ * Spawn `zeph listener` in the background if it isn't already running on
+ * this machine. The intent is that the user only ever has to know about
+ * `zeph cc` — the phone-to-tmux bridge tags along automatically. Output
+ * goes to `~/.zeph/listener.log` so it isn't lost on detach; the listener
+ * itself writes its own PID to `~/.zeph/listener.pid` on startup and
+ * removes it on graceful exit, so subsequent `zeph cc` invocations skip
+ * the spawn when a listener is already up.
+ *
+ * Failure here is non-fatal — `zeph cc` still launches the agent. The
+ * user just loses the phone-bridge feature until they restart.
+ */
+/**
+ * Rotate the listener log once it grows past 5 MB. The daemon runs for
+ * days and writes 2-3 lines per 5-s cycle, so without rotation the file
+ * climbs into the tens of megabytes range pretty quickly. We keep the
+ * previous run's tail under `.old` for post-mortem and start fresh.
+ */
+const LISTENER_LOG_MAX_BYTES = 5 * 1024 * 1024;
+const rotateListenerLogIfLarge = () => {
+    try {
+        if (!(0, fs_1.existsSync)(LISTENER_LOG_FILE))
+            return;
+        if ((0, fs_1.statSync)(LISTENER_LOG_FILE).size <= LISTENER_LOG_MAX_BYTES)
+            return;
+        (0, fs_1.renameSync)(LISTENER_LOG_FILE, LISTENER_LOG_FILE + '.old');
+    }
+    catch { /* best-effort */ }
+};
+const ensureListenerRunning = () => {
+    if (listenerAlive())
+        return;
+    const cliPath = resolveCliPath();
+    if (!cliPath || !(0, fs_1.existsSync)(cliPath))
+        return;
+    try {
+        (0, fs_1.mkdirSync)(ZEPH_DIR, { recursive: true });
+        rotateListenerLogIfLarge();
+        const out = (0, fs_1.openSync)(LISTENER_LOG_FILE, 'a');
+        const child = (0, child_process_1.spawn)(process.execPath, [cliPath, 'listener'], {
+            detached: true,
+            stdio: ['ignore', out, out],
+            env: { ...process.env, ZEPH_LISTENER_AUTOSTART: '1' },
+        });
+        child.unref();
+        console.log(`zeph: listener autostarted in background (log: ${LISTENER_LOG_FILE})`);
+    }
+    catch (err) {
+        console.error(`zeph: listener autostart failed: ${err.message}`);
+    }
+};
+/**
+ * Launch the agent in a named tmux session (or directly if nested) and
+ * forward its exit code. `extra` is appended to the agent invocation, so
+ * `zeph cc --resume foo` runs `claude --resume foo` inside the session.
+ * Returns when the agent exits.
+ */
+const handleAgentSession = (agent, extra = []) => {
+    // Best-effort: make sure the phone-bridge daemon is running before we
+    // launch the agent. The user shouldn't need to remember a second
+    // command for the picker on their phone to work.
+    ensureListenerRunning();
+    return new Promise((resolve) => {
+        const { cmd, args } = targetForAgent(agent, extra);
+        const start = Date.now();
+        const child = (0, child_process_1.spawn)(cmd, args, { stdio: 'inherit' });
+        child.on('exit', (code) => {
+            const dur = Date.now() - start;
+            // Short-lived non-zero exits are the symptom of "ran from a
+            // pane that isn't a real TTY" (iTerm tmux integration pane,
+            // some IDE terminals). The user otherwise just sees their
+            // shell return with `[exited]` and no clue what went wrong.
+            if (code && code !== 0 && dur < 2000) {
+                console.error(`zeph: ${cmd} ${args.join(' ')} exited ${code} after ${dur}ms.\n` +
+                    `  If this terminal is itself inside tmux (or an iTerm/Warp\n` +
+                    `  tmux-integration pane), run \`zeph cc\` from a plain shell\n` +
+                    `  pane instead — \`tmux new\` needs a real TTY to attach.`);
+            }
+            resolve(code ?? 0);
+        });
+        child.on('error', (err) => {
+            if (err.code === 'ENOENT') {
+                console.error(`zeph: '${cmd}' not found on PATH`);
+                resolve(127);
+            }
+            else {
+                console.error(`zeph: failed to spawn ${cmd}: ${err.message}`);
+                resolve(1);
+            }
+        });
+    });
+};
+exports.handleAgentSession = handleAgentSession;

package/dist/zeph-hook.d.ts

@@ -0,0 +1,23 @@
+import type { ZephOptions, NotifyPayload, NotifyResult, ListParams, ListResult, DismissOneResult, DismissAllResult, UploadRequestResult } from './types.js';
+export declare class ZephHook {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private cryptoInitialized;
+    constructor(options: ZephOptions);
+    private ensureCrypto;
+    notify(payload: NotifyPayload): Promise<NotifyResult>;
+    private notifyWithFile;
+    requestUpload(params: {
+        fileName: string;
+        fileType: string;
+        fileSize: number;
+    }): Promise<UploadRequestResult>;
+    uploadToS3(url: string, content: string | Buffer, contentType: string): Promise<void>;
+    list(params?: ListParams): Promise<ListResult>;
+    dismiss(pushId: string): Promise<DismissOneResult>;
+    dismissAll(): Promise<DismissAllResult>;
+    private request;
+    private parseError;
+}
+//# sourceMappingURL=zeph-hook.d.ts.map

package/dist/zeph-hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zeph-hook.d.ts","sourceRoot":"","sources":["../src/zeph-hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,UAAU,EAAY,gBAAgB,EAAE,gBAAgB,EAAoB,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAexL,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IAEnC,OAAO,CAAC,iBAAiB,CAAS;gBAEtB,OAAO,EAAE,WAAW;YASlB,YAAY;IAYpB,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;YA6B7C,cAAc;IAsDtB,aAAa,CAAC,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAK7G,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAcrF,IAAI,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAmB9C,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAKlD,UAAU,IAAI,OAAO,CAAC,gBAAgB,CAAC;YAK/B,OAAO;IAiCrB,OAAO,CAAC,UAAU;CASnB"}