insta 0.0.1 → 0.0.3

package/dist/index.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { Command } from 'commander';
+import { ApiError } from './api.js';
+import { die } from './util.js';
+import * as auth from './commands/auth.js';
+import * as org from './commands/org.js';
+import * as project from './commands/project.js';
+import * as branch from './commands/branch.js';
+import * as services from './commands/services.js';
+import * as secretsCmd from './commands/secrets.js';
+import { deploy } from './commands/deploy.js';
+import * as computeCmd from './commands/compute.js';
+import { manifest } from './commands/manifest.js';
+import * as govern from './commands/govern.js';
+import * as observe from './commands/observe.js';
+import * as obs from './commands/metrics.js';
+import { billing, billingUpgrade, billingPortal } from './commands/billing.js';
+function onError(e) {
+    if (e instanceof ApiError)
+        die(`${e.message} (HTTP ${e.status})`);
+    die(e instanceof Error ? e.message : String(e));
+}
+// Wrap an async action so rejections surface as clean CLI errors.
+const guard = (fn) => (...a) => fn(...a).then(() => undefined).catch(onError);
+const program = new Command();
+// Version resolution: INSTA_CLI_VERSION (baked into the standalone binary via bun build --define) →
+// the installed package.json (npm/node — ../package.json sits beside dist/) → 0.0.0.
+function resolveVersion() {
+    if (process.env.INSTA_CLI_VERSION)
+        return process.env.INSTA_CLI_VERSION;
+    try {
+        return JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+program.name('insta').description('InstaCloud CLI — manage projects, branches, secrets, deploys').version(resolveVersion());
+// ---- auth ----
+program.command('login').description('Log in with email + password, or --oauth <github|google> (browser)')
+    .option('--email <email>', 'account email')
+    .option('--password <password>', 'account password (else $INSTA_PASSWORD or prompt)')
+    .option('--oauth <provider>', 'browser OAuth login: github | google')
+    .option('--api-url <url>', 'control-plane API base URL')
+    .action(guard((o) => auth.login(o)));
+program.command('logout').description('Log out and clear local tokens').action(guard(() => auth.logout()));
+program.command('status').description('Show login + linked project').option('--json').action(guard((o) => auth.status(o)));
+// ---- org ----
+const orgCmd = program.command('org').description('Manage organizations');
+orgCmd.command('list').option('--json').action(guard((o) => org.orgList(o)));
+orgCmd.command('create <name>').action(guard((name) => org.orgCreate(name)));
+// ---- project ----
+const pj = program.command('project').description('Manage projects');
+pj.command('create <name>').option('--org <id>', 'org to create under (default: personal)').action(guard((name, o) => project.projectCreate(name, o)));
+pj.command('list').option('--org <id>').option('--json').action(guard((o) => project.projectList(o)));
+pj.command('link <id>').description('Link a project to this directory').action(guard((id) => project.projectLink(id)));
+pj.command('delete').option('--project <id>').action(guard((o) => project.projectDelete(o)));
+// ---- branch ----
+const br = program.command('branch').description('Manage branch environments');
+br.command('create <name>').option('--from <branch>', 'parent branch (default: current)').action(guard((name, o) => branch.branchCreate(name, o)));
+br.command('list').option('--json').action(guard((o) => branch.branchList(o)));
+br.command('switch <name>').action(guard((name) => branch.branchSwitch(name)));
+br.command('delete <name>').action(guard((name) => branch.branchDelete(name)));
+// ---- services (opt-in postgres/storage/compute) ----
+const svc = program.command('services').alias('svc').description('Manage project services (postgres|storage|compute)');
+svc.command('add <type> <name>').description('Provision a service on demand (assigns a default domain for postgres/compute)')
+    .action(guard((type, name) => services.servicesAdd(type, name)));
+svc.command('list').option('--json').action(guard((o) => services.servicesList(o)));
+svc.command('remove <type> <name>').description('Remove a service and destroy its resources')
+    .action(guard((type, name) => services.servicesRemove(type, name)));
+svc.command('scale <type> <name> <number> [region]').description('Set a compute service machine count (paid plans only)')
+    .option('--json').action(guard((type, name, number, region, o) => services.servicesScale(type, name, number, region, o)));
+svc.command('upgrade <type> <name> <spec>').description('Change a compute/postgres service spec (paid plans only)')
+    .option('--json').action(guard((type, name, spec, o) => services.servicesUpgrade(type, name, spec, o)));
+// ---- secrets (seam) ----
+const sec = program.command('secrets').description('Fetch the credential bundle (secret seam) into .env')
+    .option('--branch <branch>').option('-o, --output <file>', 'output file (default .env)').option('--print', 'print instead of writing').option('--json')
+    .action(guard((o) => secretsCmd.secrets(o)));
+sec.command('list').description('List secret names only').option('--branch <branch>').action(guard((o) => secretsCmd.secretsList(o)));
+// ---- deploy ----
+program.command('deploy [dir]').description('Deploy a source directory (built remotely on Fly) or a prebuilt --image to a branch compute group')
+    .option('--image <url>', 'prebuilt container image to deploy (instead of a source dir)').option('--branch <b>').option('--group <g>').option('--port <p>')
+    .action(guard((dir, o) => deploy(dir, o)));
+// ---- compute custom domains (bring your own domain → Fly cert + routing) ----
+const compute = program.command('compute').description('Compute custom domains (bring your own domain)');
+compute.command('set-domain <host>').description('Attach a custom domain to a branch compute service (gated: deploy)')
+    .option('--branch <b>').option('--group <g>').option('--json').action(guard((host, o) => computeCmd.setDomain(host, o)));
+compute.command('check-domain <host>').description("Show a custom domain's cert status + required DNS records")
+    .option('--branch <b>').option('--group <g>').option('--json').action(guard((host, o) => computeCmd.checkDomain(host, o)));
+compute.command('remove-domain <host>').description('Detach a custom domain (gated: deploy)')
+    .option('--branch <b>').option('--group <g>').action(guard((host, o) => computeCmd.removeDomain(host, o)));
+// ---- manifest ----
+program.command('manifest').description('Print an agent-legible view of the project environments').option('--json').action(guard((o) => manifest(o)));
+// ---- observability ----
+program.command('metrics <target> [group]').description('Service metrics (target: db|compute)')
+    .option('--branch <b>').option('--from <unix>').option('--to <unix>').option('--step <s>').option('--json')
+    .action(guard((target, group, o) => obs.metrics(target, group, o)));
+program.command('logs <target> [group]').description('Service runtime logs (target: db|compute)')
+    .option('--branch <b>').option('--limit <n>').option('--region <r>').option('--instance <i>').option('--json')
+    .action(guard((target, group, o) => obs.logs(target, group, o)));
+program.command('usage').description('Usage for the current billing cycle by billing dimension (org by default; --proj for one project)')
+    .option('--from <unix>').option('--to <unix>').option('--proj [id]', 'show one project (the linked one, or a given id) instead of the whole org').option('--json')
+    .action(guard((o) => obs.usage(o)));
+const bill = program.command('billing').description('Current billing cycle summary (tier / credit / used / overage)')
+    .option('--org <id>', 'target org (default: linked project\'s org)').option('--json')
+    .action(guard((o) => billing(o)));
+bill.command('upgrade <tier>').description('Subscribe the org to a paid tier (pro|enterprise) via Stripe Checkout')
+    .option('--org <id>').option('--no-open', 'print the URL instead of opening a browser').option('--json')
+    .action(guard((tier, o) => billingUpgrade(tier, o)));
+bill.command('portal').description('Open the Stripe Customer Portal (change plan / card / cancel)')
+    .option('--org <id>').option('--no-open', 'print the URL instead of opening a browser').option('--json')
+    .action(guard((o) => billingPortal(o)));
+// ---- events (audit timeline) ----
+program.command('events').description('Show the audit + agent-event timeline').option('--branch <b>').option('--limit <n>').option('--json').action(guard((o) => govern.events(o)));
+// ---- approvals ----
+const ap = program.command('approvals').description('Governance approvals (HITL)');
+ap.command('list').option('--status <s>', 'pending|granted|denied|consumed').option('--json').action(guard((o) => govern.approvalsList(o)));
+ap.command('approve <id>').option('--always', 'also set the policy to allow').action(guard((id, o) => govern.approvalsApprove(id, o)));
+ap.command('deny <id>').action(guard((id) => govern.approvalsDeny(id)));
+// ---- observe (local credential audit) ----
+const ob = program.command('observe').description('Local credential-audit hook');
+ob.command('install').description('Install the PostToolUse hook into this project').action(guard(() => observe.observeInstall()));
+ob.command('uninstall').action(guard(() => observe.observeUninstall()));
+ob.command('report').description('Render the local credential audit').option('--json').action(guard((o) => observe.observeReport(o)));
+ob.command('sync').description('Upload findings into the project timeline').action(guard(() => observe.observeSync()));
+// ---- policy ----
+const pol = program.command('policy').description('Governance policy');
+pol.command('get').option('--json').action(guard((o) => govern.policyGet(o)));
+pol.command('set <action> <decision>').description('action: secrets.read|deploy|project.delete|branch.delete|service.add|service.remove|service.scale|service.upgrade; decision: allow|deny|approve').action(guard((a, d) => govern.policySet(a, d)));
+program.parseAsync(process.argv);
+//# sourceMappingURL=index.js.map

package/dist/observe/hook.js

@@ -0,0 +1,62 @@
+// PostToolUse hook: reads a tool-use event on stdin (Claude Code / Codex), scans every string
+// surface for credential exposure, and appends findings to ./.insta/audit.jsonl. Ported from firth.
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { scanEvent } from './scanner.js';
+export function recordFindings(event, baseDir) {
+    const instaDir = join(baseDir, '.insta');
+    const instaAbs = resolve(instaDir);
+    const selfDir = dirname(fileURLToPath(import.meta.url));
+    const ignore = (p) => {
+        let ap;
+        try {
+            ap = resolve(p);
+        }
+        catch {
+            return false;
+        }
+        return ap.startsWith(instaAbs) || ap.startsWith(selfDir);
+    };
+    const findings = scanEvent(event, { ignorePath: ignore });
+    if (findings.length === 0)
+        return 0;
+    const common = {
+        ts: new Date().toISOString(),
+        session_id: event.session_id ?? null,
+        tool: event.tool_name ?? null,
+        cwd: event.cwd ?? null,
+    };
+    mkdirSync(instaDir, { recursive: true });
+    const lines = findings.map((f) => JSON.stringify({ ...common, ...f })).join('\n') + '\n';
+    appendFileSync(join(instaDir, 'audit.jsonl'), lines, 'utf8');
+    return findings.length;
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const c of process.stdin)
+        chunks.push(c);
+    return Buffer.concat(chunks).toString('utf8');
+}
+export async function main() {
+    let event;
+    try {
+        event = JSON.parse(await readStdin());
+    }
+    catch {
+        process.exit(0);
+    }
+    const base = process.env.CLAUDE_PROJECT_DIR || event.cwd || '.';
+    try {
+        recordFindings(event, base);
+    }
+    catch (e) {
+        process.stderr.write(`insta-observe: ${e instanceof Error ? e.message : e}\n`);
+    }
+    process.exit(0);
+}
+// Run only when executed directly (the materialized .insta/observe/hook.js entry).
+// Imported by tests → guard is false → main() does not run.
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
+    void main();
+//# sourceMappingURL=hook.js.map

package/dist/observe/install.js

@@ -0,0 +1,91 @@
+// Install the observe hook into a project's agent harness (Claude Code / Codex) and materialize
+// the standalone hook + scanner into ./.insta/observe. Ported from firth (.firth -> .insta).
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const MARKER = 'insta-observe';
+const DEFAULT_ASSET_DIR = dirname(fileURLToPath(import.meta.url)); // built: cli/dist/observe
+function cliVersion() {
+    try {
+        return JSON.parse(readFileSync(join(DEFAULT_ASSET_DIR, '..', '..', 'package.json'), 'utf8')).version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+function isInstaHook(h) {
+    if (h._insta === MARKER)
+        return true;
+    const blob = `${h.command ?? ''} ${(h.args ?? []).join(' ')}`;
+    return blob.includes('observe/hook.'); // matches .insta/observe/hook.js; trailing dot avoids matching user paths
+}
+function upsert(root, entry) {
+    root.hooks ??= {};
+    const post = Array.isArray(root.hooks.PostToolUse) ? root.hooks.PostToolUse : [];
+    for (const g of post)
+        g.hooks = (g.hooks ?? []).filter((h) => !isInstaHook(h));
+    const pruned = post.filter((g) => (g.hooks ?? []).length > 0);
+    pruned.push(entry);
+    root.hooks.PostToolUse = pruned;
+}
+function registerHarness(filePath, entry) {
+    const root = existsSync(filePath) ? JSON.parse(readFileSync(filePath, 'utf8')) : {};
+    upsert(root, entry);
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, JSON.stringify(root, null, 2) + '\n');
+}
+function unregisterHarness(filePath) {
+    if (!existsSync(filePath))
+        return;
+    const root = JSON.parse(readFileSync(filePath, 'utf8'));
+    const post = root?.hooks?.PostToolUse;
+    if (!Array.isArray(post))
+        return;
+    for (const g of post)
+        g.hooks = (g.hooks ?? []).filter((h) => !isInstaHook(h));
+    root.hooks.PostToolUse = post.filter((g) => (g.hooks ?? []).length > 0);
+    writeFileSync(filePath, JSON.stringify(root, null, 2) + '\n');
+}
+function materialize(cwd, assetDir) {
+    const dest = join(cwd, '.insta', 'observe');
+    mkdirSync(dest, { recursive: true });
+    copyFileSync(join(assetDir, 'hook.js'), join(dest, 'hook.js')); // throws if assets missing (e.g. not built)
+    copyFileSync(join(assetDir, 'scanner.js'), join(dest, 'scanner.js'));
+    writeFileSync(join(dest, 'package.json'), JSON.stringify({ type: 'module' }, null, 2) + '\n'); // run .js as ESM
+    writeFileSync(join(dest, 'VERSION'), cliVersion() + '\n');
+}
+function claudeEntry() {
+    return { matcher: '*', hooks: [{ type: 'command', command: 'node',
+                args: ['${CLAUDE_PROJECT_DIR}/.insta/observe/hook.js'], timeout: 15, _insta: MARKER }] };
+}
+function codexEntry(cwd) {
+    const abs = join(cwd, '.insta', 'observe', 'hook.js'); // Codex doesn't expand ${CLAUDE_PROJECT_DIR}; use an absolute path
+    return { matcher: '*', hooks: [{ type: 'command', command: `node ${JSON.stringify(abs)}`, timeout: 15, _insta: MARKER }] };
+}
+export function installObserve(opts) {
+    materialize(opts.cwd, opts.assetDir ?? DEFAULT_ASSET_DIR); // hook required → let a missing asset throw to the caller
+    let claude = false;
+    let codex = false;
+    try {
+        registerHarness(join(opts.cwd, '.claude', 'settings.json'), claudeEntry());
+        claude = true;
+    }
+    catch { /* skip malformed */ }
+    try {
+        registerHarness(join(opts.cwd, '.codex', 'hooks.json'), codexEntry(opts.cwd));
+        codex = true;
+    }
+    catch { /* skip malformed */ }
+    return { claude, codex };
+}
+export function uninstallObserve(cwd) {
+    try {
+        unregisterHarness(join(cwd, '.claude', 'settings.json'));
+    }
+    catch { /* skip */ }
+    try {
+        unregisterHarness(join(cwd, '.codex', 'hooks.json'));
+    }
+    catch { /* skip */ }
+}
+//# sourceMappingURL=install.js.map

package/dist/observe/report.js

@@ -0,0 +1,70 @@
+const SEV_LABEL = { high: 'HIGH', warn: 'warn', info: 'info' };
+const SINK_ORDER = ['network', 'git', 'nonsecret_file', 'stdout'];
+export function renderReport(rows) {
+    if (rows.length === 0)
+        return 'Audit log is empty — nothing recorded yet (install the hook and let an agent run).';
+    const exposures = rows.filter((r) => r.kind === 'exposure');
+    const touches = rows.filter((r) => r.kind === 'touch');
+    const ts = rows.map((r) => String(r.ts ?? '')).filter(Boolean).sort();
+    const span = ts.length ? `${ts[0].slice(0, 19)}  →  ${ts[ts.length - 1].slice(0, 19)}` : 'unknown';
+    const uniqueSecrets = new Set(rows.map((r) => r.fingerprint));
+    const L = [];
+    L.push('='.repeat(64));
+    L.push(' InstaCloud Observe — what your agents did to your credentials');
+    L.push('='.repeat(64));
+    L.push(` window      : ${span}`);
+    L.push(` events      : ${rows.length} findings across ${uniqueSecrets.size} distinct secrets`);
+    L.push(` exposures   : ${exposures.length}  (secrets that left a safe place)`);
+    L.push(` touches     : ${touches.length}  (secrets the agent handled)`);
+    L.push('='.repeat(64));
+    if (exposures.length) {
+        L.push('\n⚠  EXPOSURES (look at these first)\n');
+        const bySink = new Map();
+        for (const r of exposures) {
+            const k = String(r.sink ?? '?');
+            const group = bySink.get(k);
+            if (group) {
+                group.push(r);
+            }
+            else {
+                bySink.set(k, [r]);
+            }
+        }
+        const sinks = [...SINK_ORDER, ...[...bySink.keys()].filter((s) => !SINK_ORDER.includes(s))];
+        for (const sink of sinks) {
+            const group = bySink.get(sink);
+            if (!group)
+                continue;
+            L.push(`  ┌─ sink: ${sink}  (${group.length} finding(s))`);
+            for (const r of group) {
+                L.push(`  │  [${SEV_LABEL[String(r.severity)] ?? '?'}] ${r.note ?? ''}`);
+                L.push(`  │     secret : ${r.fingerprint}`);
+                L.push(`  │     where  : ${r.surface}  (tool ${r.tool})`);
+                L.push(`  │     when   : ${String(r.ts ?? '').slice(0, 19)}`);
+                if (r.snippet)
+                    L.push(`  │     context: ${r.snippet}`);
+            }
+            L.push('  └─');
+        }
+    }
+    else {
+        L.push('\n✓ No exposures recorded.\n');
+    }
+    if (touches.length) {
+        L.push('\n·  TOUCHES (informational)\n');
+        const counter = new Map();
+        for (const r of touches) {
+            const k = `${String(r.detector ?? '')}|||${String(r.note ?? '')}`;
+            counter.set(k, (counter.get(k) ?? 0) + 1);
+        }
+        for (const [k, count] of [...counter.entries()].sort((a, b) => b[1] - a[1])) {
+            const sep = k.indexOf('|||');
+            const detector = k.slice(0, sep);
+            const note = k.slice(sep + 3);
+            L.push(`   ${String(count).padStart(3)}×  ${detector}  — ${note}`);
+        }
+    }
+    L.push('\n(local audit only — nothing in this report has left your machine)');
+    return L.join('\n');
+}
+//# sourceMappingURL=report.js.map

package/dist/observe/scanner.js

@@ -0,0 +1,189 @@
+import { createHash } from 'node:crypto';
+const DETECTORS = [
+    { name: 'aws_access_key_id', rx: /\b(?:AKIA|ASIA|AGPA|AIDA|AROA)[0-9A-Z]{16}\b/gd, group: false },
+    { name: 'aws_secret_access_key', rx: /aws_secret_access_key\s*[:=]\s*['"]?([A-Za-z0-9/+]{40})/gid, group: true },
+    { name: 'github_token', rx: /\bgh[pousr]_[A-Za-z0-9]{36,}\b/gd, group: false },
+    { name: 'github_pat', rx: /\bgithub_pat_[A-Za-z0-9_]{82}\b/gd, group: false },
+    { name: 'slack_token', rx: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/gd, group: false },
+    { name: 'stripe_secret_key', rx: /\b[rs]k_(?:live|test)_[A-Za-z0-9]{16,}\b/gd, group: false },
+    { name: 'llm_api_key', rx: /\bsk-(?:ant-)?[A-Za-z0-9_-]{20,}\b/gd, group: false },
+    { name: 'google_api_key', rx: /\bAIza[0-9A-Za-z_-]{35}\b/gd, group: false },
+    { name: 'private_key_block', rx: /-----BEGIN (?:[A-Z ]+ )?PRIVATE KEY-----/gd, group: false },
+    { name: 'jwt', rx: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/gd, group: false },
+    { name: 'db_conn_string', rx: /\b(?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|redis|amqp):\/\/[^:\s/@]+:[^@\s/]+@[^\s'"]+/gd, group: false },
+    { name: 'bearer_token', rx: /\bbearer\s+([A-Za-z0-9._-]{20,})/gid, group: true },
+    { name: 'generic_secret_assignment', rx: /\b(?:password|passwd|secret|api[_-]?key|access[_-]?token|auth[_-]?token|client[_-]?secret|private[_-]?key)\b\s*[:=]\s*['"]?([^\s'"]{8,})/gid, group: true },
+];
+const PLACEHOLDER = /^(?:your[_-]|example|changeme|placeholder|dummy|sample|redacted|secret|x{4,}|<.+>|\.\.\.|0{6,}|1234567|test[_-]?(?:key|token|secret))/i;
+const REFERENCE = /(process\.env|os\.environ|getenv|import\.meta|\$\{|\$[A-Za-z_]|config\.|settings\.|^env\.|^[A-Z][A-Z0-9_]{3,}$)/;
+// A captured value that is a code expression — a bare identifier followed by ≥1 member access,
+// call, or index (authPassword.value, req.body.password, getSecret()) — is a reference, not a
+// literal secret. A bare identifier with no suffix (e.g. hunter2pass) is NOT excused, so real
+// unquoted/quoted literals still fire.
+const CODE_REFERENCE = /^[A-Za-z_$][\w$]*(?:\??\.[A-Za-z_$][\w$]*|\([^)]*\)|\[[^\]]*\])+$/;
+const SECRET_FILE = /(?:^|\/)(?:\.env(?:\.[A-Za-z0-9_]+)?|\.aws\/credentials|\.ssh\/id_(?:rsa|dsa|ecdsa|ed25519)|id_(?:rsa|dsa|ecdsa|ed25519)|\.npmrc|\.pypirc|\.netrc|\.git-credentials|\.kube\/config|kubeconfig|\.docker(?:cfg|\/config\.json)|credentials\.json|service-account[^/]*\.json|[^/]+\.(?:pem|key|p12|pfx|keystore|jks))$/i;
+const SECRET_FILE_SAFE = /\.(?:example|sample|template|dist)$|\.pub$/i;
+// apply_patch envelope markers (Codex). Format-based, so extraction is field-name-independent.
+const PATCH_FILE = /^\*\*\* (?:Add|Update|Delete|Move) File: (.+?)\s*$/gim;
+const NETWORK = /\b(?:curl|wget|httpie|http|nc|ncat|netcat|scp|sftp|ssh|telnet|rsync)\b/i;
+const PRINT = /\b(?:echo|printf|cat|print|less|more|head|tail|xxd|base64|env|printenv|set)\b/i;
+const GIT_WRITE = /\bgit\s+(?:add|commit|push|stash)\b/i;
+export function isSecretFile(path) {
+    if (!path)
+        return false;
+    if (SECRET_FILE_SAFE.test(path))
+        return false;
+    return SECRET_FILE.test(path);
+}
+function fingerprint(secret, detector) {
+    const h = createHash('sha256').update(secret, 'utf8').digest('hex').slice(0, 8);
+    const last4 = secret.length >= 8 ? secret.slice(-4) : '';
+    const tail = last4 ? '••••' + last4 : '••••';
+    return `${detector}:${tail}:#${h}`;
+}
+function snippet(text, span, fp) {
+    const [s, e] = span;
+    const redacted = text.slice(0, s) + '«' + fp + '»' + text.slice(e);
+    const marker = '«' + fp + '»';
+    const i = redacted.indexOf(marker);
+    const start = Math.max(0, i - 36);
+    const end = Math.min(redacted.length, i + marker.length + 36);
+    let out = redacted.slice(start, end).replace(/\s+/g, ' ').trim();
+    if (start > 0)
+        out = '…' + out;
+    if (end < redacted.length)
+        out = out + '…';
+    return out.slice(0, 160);
+}
+function leaves(obj, prefix) {
+    const out = [];
+    const walk = (o, p) => {
+        if (typeof o === 'string')
+            out.push([p, o]);
+        else if (Array.isArray(o))
+            o.forEach((v, idx) => walk(v, `${p}[${idx}]`));
+        else if (o && typeof o === 'object')
+            for (const [k, v] of Object.entries(o))
+                walk(v, `${p}.${k}`);
+    };
+    walk(obj, prefix);
+    return out;
+}
+function applyPatchPaths(ti) {
+    const paths = [];
+    for (const [, text] of leaves(ti, 'input')) {
+        PATCH_FILE.lastIndex = 0;
+        let m;
+        while ((m = PATCH_FILE.exec(text)) !== null) {
+            if (m[1])
+                paths.push(m[1]);
+        }
+    }
+    return paths;
+}
+function scanText(text) {
+    const hits = [];
+    for (const { name, rx, group } of DETECTORS) {
+        rx.lastIndex = 0;
+        let m;
+        while ((m = rx.exec(text)) !== null) {
+            if (m.index === rx.lastIndex)
+                rx.lastIndex++; // zero-width guard
+            const gi = group ? 1 : 0;
+            const secret = m[gi];
+            const span = m.indices?.[gi];
+            if (!secret || !span)
+                continue;
+            if (PLACEHOLDER.test(secret))
+                continue;
+            if (name === 'generic_secret_assignment' && (REFERENCE.test(secret) || CODE_REFERENCE.test(secret)))
+                continue;
+            hits.push([span[0], span[1], name, secret]);
+        }
+    }
+    hits.sort((a, b) => a[0] - b[0] || a[1] - b[1]); // stable: earlier detector wins an equal span
+    const kept = [];
+    for (const r of hits) {
+        if (kept.some((k) => !(r[1] <= k[0] || r[0] >= k[1])))
+            continue;
+        kept.push(r);
+    }
+    return kept;
+}
+function classify(tool, side, command, filePath, secretFileTarget) {
+    if (['Write', 'Edit', 'MultiEdit', 'NotebookEdit', 'apply_patch'].includes(tool) && side === 'input') {
+        if (secretFileTarget)
+            return ['touch', 'info', 'write_secret_file', `secret written to secret file ${filePath}`];
+        return ['exposure', 'high', 'nonsecret_file', `secret written into ${filePath || 'a non-secret file'}`];
+    }
+    if (tool === 'Bash' && side === 'input') {
+        if (NETWORK.test(command))
+            return ['exposure', 'high', 'network', 'secret in an outbound network command'];
+        if (GIT_WRITE.test(command))
+            return ['exposure', 'high', 'git', 'secret in a git write command'];
+        if (PRINT.test(command))
+            return ['exposure', 'warn', 'stdout', 'secret printed to stdout'];
+        return ['touch', 'info', 'shell', 'secret present in a shell command'];
+    }
+    if (side === 'output') {
+        if (tool === 'Bash')
+            return ['exposure', 'warn', 'stdout', 'secret appeared in command output'];
+        return ['touch', 'info', 'read', 'secret visible in tool output'];
+    }
+    return ['touch', 'info', 'other', 'secret handled by agent'];
+}
+export function scanEvent(event, opts = {}) {
+    const tool = event.tool_name || '?';
+    const ti = event.tool_input || {};
+    const tr = event.tool_response ?? {};
+    const filePath = ti.file_path || '';
+    const command = ti.command || '';
+    if (opts.ignorePath && filePath && opts.ignorePath(filePath))
+        return [];
+    const findings = [];
+    const seen = new Set();
+    const add = (kind, sev, detector, surface, sink, fp, snip, note) => {
+        const key = [kind, detector, surface, fp, sink].join('|');
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        findings.push({ kind, severity: sev, detector, surface, sink, fingerprint: fp, snippet: snip, note });
+    };
+    // Path-based rules (fire even without a value match).
+    if (isSecretFile(filePath)) {
+        const base = filePath.split('/').pop() ?? filePath;
+        if (tool === 'Read')
+            add('touch', 'info', 'secret_file', `${tool}.file_path`, 'read', `file:${base}`, filePath, `agent read secret file ${filePath}`);
+        else if (['Write', 'Edit', 'MultiEdit'].includes(tool))
+            add('touch', 'info', 'secret_file', `${tool}.file_path`, 'write_secret_file', `file:${base}`, filePath, `agent wrote secret file ${filePath}`);
+    }
+    if (command && GIT_WRITE.test(command)) {
+        for (const tok of command.match(/[^\s'"]+/g) ?? []) {
+            if (isSecretFile(tok)) {
+                const base = tok.split('/').pop() ?? tok;
+                add('exposure', 'high', 'secret_file', 'Bash.command', 'git', `file:${base}`, `git ... ${tok}`, `secret file ${tok} staged/committed via git`);
+            }
+        }
+    }
+    // Value-based rules: scan every string surface of input and output.
+    const patchPaths = tool === 'apply_patch' ? applyPatchPaths(ti) : [];
+    const secretFileTarget = isSecretFile(filePath) || patchPaths.some((p) => isSecretFile(p));
+    for (const p of patchPaths) {
+        if (isSecretFile(p)) {
+            const base = p.split('/').pop() ?? p;
+            add('touch', 'info', 'secret_file', 'apply_patch.input', 'write_secret_file', `file:${base}`, p, `agent wrote secret file ${p} via apply_patch`);
+        }
+    }
+    for (const [surface, text] of [...leaves(ti, 'input'), ...leaves(tr, 'output')]) {
+        if (!text || text.length > 1_000_000)
+            continue;
+        const side = surface.startsWith('input') ? 'input' : 'output';
+        for (const [start, end, detector, secret] of scanText(text)) {
+            const fp = fingerprint(secret, detector);
+            const [kind, sev, sink, note] = classify(tool, side, command, filePath, secretFileTarget);
+            add(kind, sev, detector, `${tool}:${surface}`, sink, fp, snippet(text, [start, end], fp), note);
+        }
+    }
+    return findings;
+}
+//# sourceMappingURL=scanner.js.map

package/dist/util.js

@@ -0,0 +1,57 @@
+// Output + small pure helpers (env serialization is unit-tested).
+import { createInterface } from 'node:readline';
+import { spawn } from 'node:child_process';
+// Best-effort: open a URL in the user's default browser. Returns false if we couldn't launch.
+export function openUrl(url) {
+    const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+    try {
+        const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
+        child.on('error', () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function die(msg) {
+    process.stderr.write(`error: ${msg}\n`);
+    process.exit(1);
+}
+export function printJson(v) {
+    process.stdout.write(JSON.stringify(v, null, 2) + '\n');
+}
+export function info(msg) {
+    process.stdout.write(msg + '\n');
+}
+// If the platform gated the action (HTTP 202), tell the user how to get it approved. Returns
+// true when an approval is pending (caller should stop).
+export function handleApproval(res) {
+    if (res.status === 202 && res.body?.status === 'approval_required') {
+        info(`approval required for ${res.body.action} — run: insta approvals approve ${res.body.approvalId}`);
+        return true;
+    }
+    return false;
+}
+// Serialize a credential bundle to .env text. All values are double-quoted (connection strings
+// contain special chars); backslashes and quotes are escaped so dotenv parsers read them back exactly.
+export function serializeEnv(bundle) {
+    return (Object.entries(bundle)
+        .map(([k, v]) => `${k}="${v.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`)
+        .join('\n') + '\n');
+}
+// Hidden password prompt (best-effort: mutes echo on a TTY).
+export function promptPassword(label = 'Password: ') {
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        const stdout = process.stdout;
+        process.stdout.write(label);
+        let captured = '';
+        stdout._writeToOutput = (s) => { if (s.includes('\n'))
+            process.stdout.write('\n'); };
+        rl.on('line', (line) => { captured = line; rl.close(); });
+        rl.on('close', () => resolve(captured));
+    });
+}
+//# sourceMappingURL=util.js.map

package/package.json

@@ -1,11 +1,33 @@
 {
   "name": "insta",
-  "version": "0.0.1",
-  "description": "React UI Components",
-  "main": "index.js",
+  "version": "0.0.3",
+  "type": "module",
+  "description": "InstaCloud CLI — a thin client of the platform control-plane API.",
+  "keywords": ["insta", "insforge", "cli", "backend", "baas", "platform"],
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/InsForge/insta-cli#readme",
+  "repository": { "type": "git", "url": "git+https://github.com/InsForge/insta-cli.git" },
+  "bugs": { "url": "https://github.com/InsForge/insta-cli/issues" },
+  "bin": { "insta": "dist/index.js" },
+  "files": ["dist/**/*.js"],
+  "engines": { "node": ">=18" },
+  "publishConfig": { "access": "public" },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "compile": "bun build ./src/index.ts --compile --minify --outfile dist/bin/insta",
+    "build:binaries": "bash scripts/build-binaries.sh",
+    "prepublishOnly": "npm run build"
   },
-  "author": "Ansuman Shah",
-  "license": "MIT"
+  "dependencies": {
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "tsx": "^4.16.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
+  }
 }