@chipallen2/snazi 0.1.0

package/dist/config.js

@@ -0,0 +1,110 @@
+"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.DEFAULT_API_URL = exports.CONFIG_PATH = exports.CONFIG_DIR = void 0;
+exports.readConfigIfPresent = readConfigIfPresent;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+exports.CONFIG_DIR = path.join(os.homedir(), '.snazi');
+exports.CONFIG_PATH = path.join(exports.CONFIG_DIR, 'config.json');
+/** Default deployment used by `snazi init` when none is supplied. */
+exports.DEFAULT_API_URL = 'https://snazi.dev';
+/**
+ * Read config.json if it exists, WITHOUT exiting on missing/invalid input.
+ * Returns the parsed config (apiUrl trailing slash stripped) or null. Used by
+ * `snazi init` and `snazi doctor`, which must run before a valid config exists.
+ */
+function readConfigIfPresent() {
+    try {
+        if (!fs.existsSync(exports.CONFIG_PATH))
+            return null;
+        const cfg = JSON.parse(fs.readFileSync(exports.CONFIG_PATH, 'utf8'));
+        if (cfg && typeof cfg === 'object') {
+            if (typeof cfg.apiUrl === 'string')
+                cfg.apiUrl = cfg.apiUrl.replace(/\/+$/, '');
+            return cfg;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Load and validate config.json. Exits with a helpful message if missing. */
+function loadConfig() {
+    if (!fs.existsSync(exports.CONFIG_PATH)) {
+        console.error(JSON.stringify({
+            error: `Config not found at ${exports.CONFIG_PATH}. Run 'snazi init' to create it.`,
+        }));
+        process.exit(2);
+    }
+    let raw;
+    try {
+        raw = fs.readFileSync(exports.CONFIG_PATH, 'utf8');
+    }
+    catch (e) {
+        console.error(JSON.stringify({ error: `Cannot read config: ${String(e)}` }));
+        process.exit(2);
+    }
+    let cfg;
+    try {
+        cfg = JSON.parse(raw);
+    }
+    catch {
+        console.error(JSON.stringify({ error: 'config.json is not valid JSON.' }));
+        process.exit(2);
+    }
+    if (!cfg.apiUrl || !cfg.apiKey) {
+        console.error(JSON.stringify({ error: 'config.json must include apiUrl and apiKey.' }));
+        process.exit(2);
+    }
+    // Normalize: strip trailing slash from apiUrl.
+    cfg.apiUrl = cfg.apiUrl.replace(/\/+$/, '');
+    if (!Array.isArray(cfg.channels))
+        cfg.channels = ['imessage'];
+    return cfg;
+}
+/** Persist config back to disk (preserving 0600 perms). */
+function saveConfig(cfg) {
+    if (!fs.existsSync(exports.CONFIG_DIR)) {
+        fs.mkdirSync(exports.CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+    fs.writeFileSync(exports.CONFIG_PATH, JSON.stringify(cfg, null, 2) + '\n', {
+        mode: 0o600,
+    });
+}

package/dist/daemon.js

@@ -0,0 +1,89 @@
+"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.LABEL = void 0;
+exports.installDaemon = installDaemon;
+/**
+ * snazi serve --install-daemon — install the launchd LaunchAgent.
+ *
+ * Writes ~/Library/LaunchAgents/com.soup-nazi.snazi-serve.plist from the
+ * template, substituting the real node binary, CLI path, bind, and port. Then
+ * prints the `launchctl` load/unload commands and the Full Disk Access note.
+ *
+ * We intentionally do NOT auto-`launchctl load` here: loading a LaunchAgent and
+ * granting Full Disk Access is a deliberate, user-visible action. We print the
+ * exact commands instead so it stays transparent.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const server_1 = require("./server");
+exports.LABEL = 'com.soup-nazi.snazi-serve';
+// Mirrors server.ts port policy (kept local to avoid coupling).
+function pickPort(cfg, port) {
+    const p = port ?? cfg.servePort ?? 8787;
+    if (!Number.isInteger(p) || p < 1 || p > 65535) {
+        throw new Error(`Invalid port: ${p}`);
+    }
+    return p;
+}
+function installDaemon(cfg, opts) {
+    const node = process.execPath;
+    // dist/daemon.js -> dist/cli.js
+    const cli = path.join(__dirname, 'cli.js');
+    if (!fs.existsSync(cli)) {
+        throw new Error(`Cannot find compiled CLI at ${cli}. Run 'npm run build' first.`);
+    }
+    const bind = (0, server_1.resolveBind)(cfg, { bind: opts.bind });
+    const port = pickPort(cfg, opts.port);
+    // Template lives next to package root: dist/daemon.js -> ../com.soup-nazi...
+    const templatePath = path.join(__dirname, '..', 'com.soup-nazi.snazi-serve.plist');
+    if (!fs.existsSync(templatePath)) {
+        throw new Error(`Plist template not found at ${templatePath}.`);
+    }
+    const logDir = path.join(os.homedir(), 'Library', 'Logs');
+    const filled = fs
+        .readFileSync(templatePath, 'utf8')
+        .replace(/__NODE__/g, node)
+        .replace(/__CLI__/g, cli)
+        .replace(/__BIND__/g, bind)
+        .replace(/__PORT__/g, String(port))
+        .replace(/__LOGDIR__/g, logDir);
+    const agentsDir = path.join(os.homedir(), 'Library', 'LaunchAgents');
+    fs.mkdirSync(agentsDir, { recursive: true });
+    const plistPath = path.join(agentsDir, `${exports.LABEL}.plist`);
+    fs.writeFileSync(plistPath, filled, { mode: 0o644 });
+    return { plistPath, bind, port, node, cli };
+}

package/dist/doctor.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctor = runDoctor;
+/**
+ * `snazi doctor` — one command that tells a new user exactly what's wrong.
+ *
+ * Checks, in order:
+ *   - Node version (>= 18, required for global fetch)
+ *   - Config present + valid (apiUrl + token)
+ *   - Server reachable with the configured token
+ *   - For each configured channel: is there a local adapter, and can it read on
+ *     THIS machine right now (platform + Full Disk Access for iMessage)?
+ *
+ * Output is JSON (like the rest of the CLI). `problems` are hard failures that
+ * set a non-zero exit code; `warnings` (server unreachable, a channel that only
+ * works remotely on this OS) are surfaced but do not fail, because remote-only
+ * use (e.g. a Windows box driving a Mac `snazi serve`) is legitimate.
+ */
+const config_1 = require("./config");
+const api_1 = require("./api");
+const channels_1 = require("./channels");
+const MIN_NODE_MAJOR = 18;
+async function runDoctor() {
+    const problems = [];
+    const warnings = [];
+    const nodeMajor = Number(process.versions.node.split('.')[0]);
+    const nodeOk = Number.isFinite(nodeMajor) && nodeMajor >= MIN_NODE_MAJOR;
+    if (!nodeOk) {
+        problems.push(`Node ${process.versions.node} is too old; snazi needs Node ${MIN_NODE_MAJOR}+ (global fetch).`);
+    }
+    const cfg = (0, config_1.readConfigIfPresent)();
+    const configPresent = Boolean(cfg);
+    const configValid = Boolean(cfg && cfg.apiUrl && cfg.apiKey);
+    if (!configPresent) {
+        problems.push(`No config at ${config_1.CONFIG_PATH}. Run 'snazi init'.`);
+    }
+    else if (!configValid) {
+        problems.push(`Config at ${config_1.CONFIG_PATH} is missing apiUrl or apiKey. Run 'snazi init'.`);
+    }
+    let serverReachable = null;
+    if (configValid && cfg) {
+        serverReachable = await (0, api_1.ping)(cfg);
+        if (!serverReachable) {
+            warnings.push(`Cannot reach ${cfg.apiUrl} with the configured token. Check the URL, token, and network.`);
+        }
+    }
+    const configuredChannels = cfg?.channels?.length
+        ? cfg.channels
+        : configValid
+            ? ['imessage']
+            : [];
+    const channels = configuredChannels.map((id) => {
+        const adapter = (0, channels_1.getAdapter)(id);
+        if (!adapter) {
+            warnings.push(`Channel '${id}' has no local adapter on this build; only remote-* (against a host that supports it) will work here.`);
+            return {
+                id,
+                known: false,
+                available: false,
+                reason: 'no local adapter on this build',
+                detail: null,
+            };
+        }
+        const av = adapter.availability();
+        if (!av.available) {
+            warnings.push(`Channel '${id}' is not readable locally: ${av.reason}`);
+        }
+        return {
+            id,
+            known: true,
+            available: av.available,
+            reason: av.reason ?? null,
+            detail: av.detail ?? null,
+        };
+    });
+    const report = {
+        ok: problems.length === 0,
+        platform: `${process.platform}/${process.arch}`,
+        node: process.versions.node,
+        node_ok: nodeOk,
+        config: {
+            path: config_1.CONFIG_PATH,
+            present: configPresent,
+            valid: configValid,
+            apiUrl: cfg?.apiUrl ?? null,
+            token_present: Boolean(cfg?.apiKey),
+        },
+        server_reachable: serverReachable,
+        channels,
+        adapters: (0, channels_1.listAdapters)().map((a) => ({
+            id: a.id,
+            display_name: a.displayName,
+            platforms: a.platforms,
+        })),
+        problems,
+        warnings,
+    };
+    return { code: problems.length === 0 ? 0 : 1, report };
+}

package/dist/init.js

@@ -0,0 +1,155 @@
+"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.runInit = runInit;
+/**
+ * `snazi init` — create or update ~/.snazi/config.json without hand-editing JSON.
+ *
+ * Works two ways:
+ *   - Interactive (a TTY): prompts for the deployment URL, the account READ
+ *     token, and the channel(s), each pre-filled with a sensible default.
+ *   - Non-interactive (agents/CI, or `--yes`): takes values from flags
+ *     (--api-url, --token, --channel) and/or an existing config. Prompts are
+ *     skipped; a missing token is a hard error with guidance.
+ *
+ * Existing config is treated as defaults and MERGED (serve/remote keys are
+ * preserved), so re-running init never clobbers unrelated settings. Prompts are
+ * written to stderr so stdout stays clean JSON for scripted callers.
+ */
+const readline = __importStar(require("node:readline/promises"));
+const config_1 = require("./config");
+/** Normalize a user-typed base URL: trim, drop trailing slash, default https. */
+function normalizeUrl(input) {
+    let u = (input ?? '').trim().replace(/\/+$/, '');
+    if (!u)
+        return '';
+    if (!/^https?:\/\//i.test(u))
+        u = `https://${u}`;
+    return u;
+}
+function maskToken(t) {
+    if (!t)
+        return '';
+    return `${t.slice(0, 6)}…(${t.length})`;
+}
+async function runInit(a) {
+    const existing = (0, config_1.readConfigIfPresent)();
+    const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY) && !a.yes;
+    const noFlags = !a.apiUrl && !a.token && !a.channel;
+    // Existing config + nothing to change + can't prompt -> no-op (don't clobber).
+    if (existing && !a.force && !interactive && noFlags) {
+        return {
+            code: 0,
+            result: {
+                ok: true,
+                note: `Config already present at ${config_1.CONFIG_PATH}. Pass --force to rewrite, flags (--api-url/--token/--channel) to update, or run interactively.`,
+                config_path: config_1.CONFIG_PATH,
+            },
+        };
+    }
+    let rl;
+    if (interactive) {
+        rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stderr,
+        });
+    }
+    const ask = async (q, def) => {
+        if (!rl)
+            return def ?? '';
+        const suffix = def ? ` [${def}]` : '';
+        const ans = (await rl.question(`${q}${suffix}: `)).trim();
+        return ans || def || '';
+    };
+    try {
+        const apiUrl = normalizeUrl(a.apiUrl ??
+            (interactive
+                ? await ask('Deployment URL', existing?.apiUrl ?? config_1.DEFAULT_API_URL)
+                : existing?.apiUrl ?? config_1.DEFAULT_API_URL));
+        const token = (a.token ??
+            (interactive
+                ? await ask('Account READ token (from the dashboard Account page)', existing?.apiKey)
+                : existing?.apiKey ?? '')).trim();
+        const channelsDefault = existing?.channels?.length
+            ? existing.channels.join(',')
+            : 'imessage';
+        const channelsRaw = a.channel ?? (interactive ? await ask('Channel(s), comma-separated', channelsDefault) : channelsDefault);
+        const channels = channelsRaw
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean);
+        if (!apiUrl) {
+            return { code: 2, result: { error: 'A deployment URL is required.' } };
+        }
+        if (!token) {
+            return {
+                code: 2,
+                result: {
+                    error: 'A READ token is required. Pass --token <token> (or run interactively). ' +
+                        'Get it from your deployment dashboard → Account page.',
+                },
+            };
+        }
+        const merged = {
+            ...(existing ?? {}),
+            apiUrl,
+            apiKey: token,
+            channels: channels.length ? channels : ['imessage'],
+        };
+        (0, config_1.saveConfig)(merged);
+        const warnings = [];
+        if (token.length < 16) {
+            warnings.push('That token looks short — double-check you copied the full READ token.');
+        }
+        return {
+            code: 0,
+            result: {
+                ok: true,
+                config_path: config_1.CONFIG_PATH,
+                apiUrl,
+                apiKey: maskToken(token),
+                channels: merged.channels,
+                warnings: warnings.length ? warnings : undefined,
+                next_steps: [
+                    'snazi doctor   # verify config, connectivity, and channel access',
+                    'snazi list-new --since 120',
+                ],
+            },
+        };
+    }
+    finally {
+        rl?.close();
+    }
+}