@stigg/terminal 0.0.1-alpha

package/dist/auth/storage.js

@@ -0,0 +1,34 @@
+import { chmod, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export function configDir() {
+    const xdg = process.env.XDG_CONFIG_HOME;
+    if (xdg)
+        return join(xdg, 'stigg');
+    return join(homedir(), '.config', 'stigg');
+}
+export function credentialsPath() {
+    return join(configDir(), 'credentials.json');
+}
+export async function saveSession(session) {
+    const dir = configDir();
+    const path = credentialsPath();
+    await mkdir(dir, { recursive: true });
+    await writeFile(path, JSON.stringify(session, null, 2), 'utf8');
+    await chmod(path, 0o600);
+    return path;
+}
+export async function loadSession() {
+    try {
+        const raw = await readFile(credentialsPath(), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return null;
+        throw e;
+    }
+}
+export async function clearSession() {
+    await rm(credentialsPath(), { force: true });
+}

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { cli } from './cli.js';
+cli();

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export declare function cli(argv?: string[]): void;

package/dist/cli.js

@@ -0,0 +1,79 @@
+import { Command } from 'commander';
+import pc from 'picocolors';
+import { dashCommand } from './commands/dash.js';
+import { envCommand } from './commands/env.js';
+import { initCommand } from './commands/init.js';
+import { mcpAddCommand } from './commands/mcp.js';
+import { skillsAddCommand } from './commands/skills.js';
+import { ConfigParseError } from './mcp/config-merge.js';
+import { runHudThenMaybeLaunch } from './ui/hud.js';
+import { messages } from './ui/messages.js';
+// Keep in sync with `version` in package.json.
+const VERSION = '0.0.1-alpha';
+function collectClient(value, prev) {
+    return [...prev, value];
+}
+export function cli(argv = process.argv) {
+    const program = new Command()
+        .name('stiggt')
+        .description('Stigg terminal — interactive setup TUI for AI coding assistants')
+        .version(VERSION)
+        .action(async () => {
+        if (!process.stdin.isTTY) {
+            program.outputHelp();
+            return;
+        }
+        await runHudThenMaybeLaunch();
+    });
+    program
+        .command('init')
+        .description('Set up Stigg in this project — auth, MCP, skills')
+        .option('--headless', 'Run without the interactive TUI')
+        .option('--force-login', 'Re-authenticate even if a valid session is cached')
+        .option('--callback-port <port>', 'Loopback port for the OAuth callback (overrides STIGG_CALLBACK_PORT)')
+        .option('--account-id <id>', 'phase 2: account ID from phase 1 listing')
+        .option('--environment-id <id>', 'phase 2: environment ID from phase 1 listing')
+        .option('--api-key-id <id>', 'phase 2: API key ID from phase 1 listing')
+        .option('-c, --client <id>', 'phase 2: limit to specific client(s); repeatable; default: host agent if detected, else --all', collectClient, [])
+        .option('--all', 'phase 2: target every detected client (overrides host-agent default)')
+        .option('--no-skills', 'phase 2: skip skill install (default: install)')
+        .option('--json', 'Emit a single JSON object on stdout instead of human-readable text')
+        .action(initCommand);
+    const mcp = program.command('mcp').description('Manage Stigg MCP entries in AI client configs');
+    mcp
+        .command('add')
+        .description('Write the Stigg MCP entry to one or more AI client configs (non-interactive)')
+        .option('--api-key <value>', 'Stigg API key (or set STIGG_API_KEY)')
+        .option('-c, --client <id>', 'target client (repeatable)', collectClient, [])
+        .option('--all', 'target every detected client')
+        .option('--json', 'JSON output')
+        .action(mcpAddCommand);
+    const skills = program
+        .command('skills')
+        .description('Manage Stigg skills install for AI clients');
+    skills
+        .command('add')
+        .description('Install Stigg skills for one or more AI clients (non-interactive)')
+        .option('-c, --client <id>', 'target client (repeatable)', collectClient, [])
+        .option('--all', 'target every detected client')
+        .option('--json', 'JSON output')
+        .action(skillsAddCommand);
+    program.command('env').description('Switch the active Stigg environment').action(envCommand);
+    program
+        .command('dash')
+        .description('Open the Stigg dashboard in your browser')
+        .action(dashCommand);
+    program.parseAsync(argv).catch((err) => {
+        if (err instanceof ConfigParseError) {
+            console.error(pc.red(`\n✗ ${messages.writes.abortMalformed(err.path)}`));
+            process.exit(2);
+        }
+        if (err instanceof Error) {
+            console.error(pc.red(`\n✗ ${err.message}`));
+        }
+        else {
+            console.error(err);
+        }
+        process.exit(1);
+    });
+}

package/dist/commands/dash.d.ts

@@ -0,0 +1 @@
+export declare function dashCommand(): Promise<void>;

package/dist/commands/dash.js

@@ -0,0 +1,24 @@
+import open from 'open';
+import pc from 'picocolors';
+import { runHud } from '../ui/hud.js';
+const DASHBOARD_URL = 'https://app.stigg.io';
+export async function dashCommand() {
+    if (process.stdin.isTTY) {
+        await runHud({ initialScreen: 'dash' });
+        return;
+    }
+    // Non-TTY fallback (CI / pipe) — plain console output.
+    console.log();
+    console.log(pc.greenBright(pc.bold('  stigg · terminal · dash')));
+    console.log(pc.dim('  ─────────────────────────'));
+    console.log();
+    console.log(`  Opening ${pc.cyan(DASHBOARD_URL)}…`);
+    console.log();
+    try {
+        await open(DASHBOARD_URL);
+    }
+    catch {
+        console.log(`  Could not launch a browser automatically. Open manually: ${pc.cyan(DASHBOARD_URL)}`);
+        console.log();
+    }
+}

package/dist/commands/debug.d.ts

@@ -0,0 +1 @@
+export declare function debugCommand(): Promise<void>;

package/dist/commands/debug.js

@@ -0,0 +1,53 @@
+import pc from "picocolors";
+import { runHud } from "../ui/hud.js";
+const SAMPLE_LOGS = [
+    {
+        time: "16:42:13.221",
+        level: "INFO",
+        source: "feature.access",
+        message: "customer=acme_corp has_access=true plan=growth feature=ai_credits",
+    },
+    {
+        time: "16:42:14.034",
+        level: "INFO",
+        source: "usage.report",
+        message: "customer=acme_corp feature=api_calls value=1 source=mcp",
+    },
+    {
+        time: "16:42:18.512",
+        level: "WARN",
+        source: "entitlement.exceeded",
+        message: "customer=acme_corp feature=api_calls usage=1001 limit=1000 reset_at=2026-07-01",
+    },
+    {
+        time: "16:42:21.118",
+        level: "INFO",
+        source: "subscription.updated",
+        message: "customer=acme_corp from=growth to=growth_v2 status=active",
+    },
+];
+const LEVEL_COLOR = {
+    INFO: pc.green,
+    WARN: pc.yellow,
+    ERROR: pc.red,
+};
+export async function debugCommand() {
+    if (process.stdin.isTTY) {
+        await runHud({ initialScreen: "debug" });
+        return;
+    }
+    // Non-TTY fallback (CI / pipe) — plain console output.
+    console.log();
+    console.log(pc.greenBright(pc.bold("  stigg · terminal · debug")));
+    console.log(pc.dim("  ──────────────────────────"));
+    console.log();
+    console.log(pc.dim("  Streaming audit + usage logs (placeholder, sample output)…"));
+    console.log();
+    for (const log of SAMPLE_LOGS) {
+        const colorFn = LEVEL_COLOR[log.level];
+        console.log(`  ${pc.dim(log.time)}  ${colorFn(log.level.padEnd(5))}  ${pc.cyan(log.source.padEnd(22))}  ${log.message}`);
+    }
+    console.log();
+    console.log(pc.dim("  (placeholder — the real command will live-tail audit + usage events for the active env, with `--since`, `--follow`, and `--filter` flags.)"));
+    console.log();
+}

package/dist/commands/env.d.ts

@@ -0,0 +1 @@
+export declare function envCommand(): Promise<void>;

package/dist/commands/env.js

@@ -0,0 +1,15 @@
+import pc from 'picocolors';
+import { runHud } from '../ui/hud.js';
+export async function envCommand() {
+    if (process.stdin.isTTY) {
+        await runHud({ initialScreen: 'env' });
+        return;
+    }
+    // Non-TTY fallback (CI / pipe) — plain console output.
+    console.log();
+    console.log(pc.greenBright(pc.bold('  stigg · terminal · env')));
+    console.log(pc.dim('  ──────────────────────────'));
+    console.log();
+    console.log(pc.dim('  Switch environments interactively by running `terminal env` from a real terminal.'));
+    console.log();
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,13 @@
+export interface InitOptions {
+    headless?: boolean;
+    forceLogin?: boolean;
+    callbackPort?: string;
+    accountId?: string;
+    environmentId?: string;
+    apiKeyId?: string;
+    client?: string[];
+    all?: boolean;
+    skills?: boolean;
+    json?: boolean;
+}
+export declare function initCommand(opts?: InitOptions): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,59 @@
+import pc from 'picocolors';
+import { runInitPhase1 } from '../headless/init-phase1.js';
+import { runInitPhase2 } from '../headless/init-phase2.js';
+import { HeadlessOptionsError } from '../headless/options.js';
+import { runHudThenMaybeLaunch } from '../ui/hud.js';
+function parseCallbackPort(raw) {
+    if (raw === undefined)
+        return undefined;
+    const port = Number(raw);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new HeadlessOptionsError(`--callback-port must be an integer between 1 and 65535 (got "${raw}")`);
+    }
+    return port;
+}
+export async function initCommand(opts = {}) {
+    try {
+        const callbackPort = parseCallbackPort(opts.callbackPort);
+        if (!opts.headless) {
+            if (!process.stdin.isTTY) {
+                process.stderr.write('\nterminal init needs an interactive terminal (TTY).\n' +
+                    'Pass --headless to run non-interactively, or run from a shell directly.\n\n');
+                process.exit(1);
+            }
+            await runHudThenMaybeLaunch({ initialScreen: 'init', callbackPort });
+            return;
+        }
+        const anyId = opts.accountId || opts.environmentId || opts.apiKeyId;
+        if (!anyId) {
+            await runInitPhase1({
+                forceLogin: opts.forceLogin,
+                callbackPort,
+                client: opts.client,
+                all: opts.all,
+                installSkills: opts.skills !== false,
+                json: opts.json,
+            });
+            return;
+        }
+        if (!opts.accountId || !opts.environmentId || !opts.apiKeyId) {
+            throw new HeadlessOptionsError('phase 2 requires all three: --account-id, --environment-id, --api-key-id');
+        }
+        await runInitPhase2({
+            accountId: opts.accountId,
+            environmentId: opts.environmentId,
+            apiKeyId: opts.apiKeyId,
+            client: opts.client,
+            all: opts.all,
+            installSkills: opts.skills !== false,
+            json: opts.json,
+        });
+    }
+    catch (e) {
+        if (e instanceof HeadlessOptionsError) {
+            process.stderr.write(`${pc.red('✗')} ${e.message}\n`);
+            process.exit(2);
+        }
+        throw e;
+    }
+}

package/dist/commands/mcp.d.ts

@@ -0,0 +1,7 @@
+export interface McpAddOptions {
+    apiKey?: string;
+    client?: string[];
+    all?: boolean;
+    json?: boolean;
+}
+export declare function mcpAddCommand(opts?: McpAddOptions): Promise<void>;

package/dist/commands/mcp.js

@@ -0,0 +1,37 @@
+import pc from 'picocolors';
+import { HeadlessOptionsError, parseClientSelection, requireApiKey } from '../headless/options.js';
+import { createReporter, fmt } from '../headless/reporter.js';
+import { runHeadlessSetup } from '../headless/setup.js';
+export async function mcpAddCommand(opts = {}) {
+    try {
+        const apiKey = requireApiKey(opts.apiKey);
+        const clients = parseClientSelection({ client: opts.client, all: opts.all }, { required: true });
+        const reporter = createReporter({ json: opts.json });
+        if (!opts.json)
+            reporter.human(fmt.heading('mcp · add'));
+        const result = await runHeadlessSetup({ apiKey, clients, installSkills: false }, {
+            onClientResult: (write, { name }) => {
+                if (!opts.json)
+                    reporter.human(fmt.ok(name, write.path));
+            },
+            onClientFail: (_id, name, reason) => {
+                reporter.stderr(fmt.fail(name, reason));
+            },
+        });
+        if (!opts.json && result.ok)
+            reporter.human('Done.');
+        reporter.emit({
+            ok: result.ok,
+            writes: result.writes,
+            skipped: result.skipped,
+        });
+        process.exit(result.ok ? 0 : 1);
+    }
+    catch (e) {
+        if (e instanceof HeadlessOptionsError) {
+            process.stderr.write(`${pc.red('✗')} ${e.message}\n`);
+            process.exit(2);
+        }
+        throw e;
+    }
+}

package/dist/commands/skills.d.ts

@@ -0,0 +1,6 @@
+export interface SkillsAddOptions {
+    client?: string[];
+    all?: boolean;
+    json?: boolean;
+}
+export declare function skillsAddCommand(opts?: SkillsAddOptions): Promise<void>;

package/dist/commands/skills.js

@@ -0,0 +1,48 @@
+import pc from 'picocolors';
+import { HeadlessOptionsError, parseClientSelection } from '../headless/options.js';
+import { createReporter, fmt } from '../headless/reporter.js';
+import { runHeadlessSetup } from '../headless/setup.js';
+export async function skillsAddCommand(opts = {}) {
+    try {
+        const clients = parseClientSelection({ client: opts.client, all: opts.all }, { required: true });
+        const reporter = createReporter({ json: opts.json });
+        if (!opts.json)
+            reporter.human(fmt.heading('skills · add'));
+        const result = await runHeadlessSetup({ apiKey: '', clients, installSkills: true, skipMcp: true }, {
+            onSkillsResult: (skillsResult) => {
+                if (skillsResult.claudeCode) {
+                    if (skillsResult.claudeCode.ok) {
+                        if (!opts.json)
+                            reporter.human(fmt.ok('Claude Code plugin', 'stigg@stigg-marketplace'));
+                    }
+                    else {
+                        reporter.stderr(fmt.fail('Claude Code plugin', skillsResult.claudeCode.reason));
+                    }
+                }
+                if (skillsResult.agentSkills) {
+                    if (skillsResult.agentSkills.ok) {
+                        if (!opts.json)
+                            reporter.human(fmt.ok('Agent skills', 'stiggio/skills'));
+                    }
+                    else {
+                        reporter.stderr(fmt.fail('Agent skills', skillsResult.agentSkills.reason));
+                    }
+                }
+            },
+        });
+        if (!opts.json && result.ok)
+            reporter.human('Done.');
+        reporter.emit({
+            ok: result.ok,
+            skillsInstall: result.skillsInstall,
+        });
+        process.exit(result.ok ? 0 : 1);
+    }
+    catch (e) {
+        if (e instanceof HeadlessOptionsError) {
+            process.stderr.write(`${pc.red('✗')} ${e.message}\n`);
+            process.exit(2);
+        }
+        throw e;
+    }
+}

package/dist/headless/host-agent.d.ts

@@ -0,0 +1,19 @@
+import type { ClientId } from '../types.js';
+export interface HostAgent {
+    /** The MCP client ID this agent corresponds to. */
+    id: ClientId;
+    /** Human-readable display name. */
+    name: string;
+    /** Agent-specific one-line restart instruction (without the leading ⚠ marker). */
+    restartHint: string;
+}
+/**
+ * Detect which AI agent (if any) is hosting this CLI invocation, based on
+ * env vars that each agent sets when it spawns shell commands.
+ *
+ * Priority: STIGG_HOST_AGENT override > Claude Code > Cursor > Codex > VS Code > null.
+ *
+ * Detection is best-effort — a false negative just falls back to the generic
+ * restart line and `--all` client default.
+ */
+export declare function detectHostAgent(): HostAgent | null;

package/dist/headless/host-agent.js

@@ -0,0 +1,64 @@
+const CLAUDE_CODE = {
+    id: 'claude-code',
+    name: 'Claude Code',
+    restartHint: 'Restart Claude Code (/exit + run `claude` again) to load Stigg MCP into your next session.',
+};
+const CURSOR = {
+    id: 'cursor',
+    name: 'Cursor',
+    restartHint: 'Restart Cursor (close and reopen the window) to load Stigg MCP.',
+};
+const VSCODE = {
+    id: 'vscode',
+    name: 'VS Code',
+    restartHint: 'Restart VS Code (close and reopen the window) to load Stigg MCP.',
+};
+const CODEX = {
+    id: 'codex',
+    name: 'Codex',
+    restartHint: 'Restart Codex (exit and run `codex` again) to load Stigg MCP.',
+};
+const CLAUDE_DESKTOP = {
+    id: 'claude-desktop',
+    name: 'Claude Desktop',
+    restartHint: 'Restart Claude Desktop (quit and reopen the app) to load Stigg MCP.',
+};
+const KNOWN_AGENTS = {
+    'claude-code': CLAUDE_CODE,
+    cursor: CURSOR,
+    vscode: VSCODE,
+    codex: CODEX,
+    'claude-desktop': CLAUDE_DESKTOP,
+};
+/**
+ * Detect which AI agent (if any) is hosting this CLI invocation, based on
+ * env vars that each agent sets when it spawns shell commands.
+ *
+ * Priority: STIGG_HOST_AGENT override > Claude Code > Cursor > Codex > VS Code > null.
+ *
+ * Detection is best-effort — a false negative just falls back to the generic
+ * restart line and `--all` client default.
+ */
+export function detectHostAgent() {
+    const override = process.env.STIGG_HOST_AGENT;
+    if (override !== undefined) {
+        const trimmed = override.trim();
+        if (trimmed === 'none')
+            return null;
+        if (trimmed !== '') {
+            const known = KNOWN_AGENTS[trimmed];
+            if (known)
+                return known;
+            process.stderr.write(`⚠  STIGG_HOST_AGENT="${trimmed}" is not a known client id; ignoring.\n`);
+        }
+    }
+    if (process.env.CLAUDECODE === '1')
+        return CLAUDE_CODE;
+    if (process.env.CURSOR_TRACE_ID || process.env.TERM_PROGRAM === 'cursor')
+        return CURSOR;
+    if (process.env.CODEX_SESSION_ID || process.env.CODEX_CLI === '1')
+        return CODEX;
+    if (process.env.TERM_PROGRAM === 'vscode')
+        return VSCODE;
+    return null;
+}

package/dist/headless/init-phase1.d.ts

@@ -0,0 +1,9 @@
+export interface PhaseOneOptions {
+    forceLogin?: boolean;
+    callbackPort?: number;
+    client?: string[];
+    all?: boolean;
+    installSkills?: boolean;
+    json?: boolean;
+}
+export declare function runInitPhase1(opts?: PhaseOneOptions): Promise<void>;