use-vibes 0.19.27-dev-cli → 0.19.29-dev-cli

package/esm/bin.js

@@ -2,10 +2,12 @@
 // Node CLI entry point — compiled by dnt with #!/usr/bin/env node shebang.
 // For Deno, use main.deno.ts instead.
 import { defaultCliOutput } from "./commands/cli-output.js";
-import { runCli } from "./run-cli.js";
-await runCli(process.argv.slice(2), {
+import { nodeLoginPlatform } from "./commands/login-platform-node.js";
+import { dispatch } from "./dispatcher.js";
+await dispatch(process.argv.slice(2), {
     output: defaultCliOutput,
     setExitCode(code) {
         process.exitCode = code;
     },
+    loginPlatform: nodeLoginPlatform,
 });

package/esm/cli/exec/handle-register.d.ts

@@ -0,0 +1,3 @@
+import type { CommandExecutable } from "../executable.js";
+export declare const handleRegisterExec: CommandExecutable;
+//# sourceMappingURL=handle-register.d.ts.map

package/esm/cli/exec/handle-register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-register.d.ts","sourceRoot":"","sources":["../../../src/cli/exec/handle-register.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAG1D,eAAO,MAAM,kBAAkB,EAAE,iBAgBhC,CAAC"}

package/esm/cli/exec/handle-register.js

@@ -0,0 +1,18 @@
+import { runRegisterHandle } from "../../commands/handle-register.js";
+export const handleRegisterExec = {
+    name: "handle register",
+    description: "Register a handle slug",
+    async run(argv, runtime) {
+        if (argv.length > 1) {
+            runtime.output.stderr("handle register accepts at most one slug argument\n");
+            return 1;
+        }
+        const slug = argv.length > 0 ? argv[0] : undefined;
+        const result = await runRegisterHandle({ slug }, runtime.output);
+        if (result.isErr()) {
+            runtime.output.stderr(String(result.Err()) + "\n");
+            return 1;
+        }
+        return 0;
+    },
+};

package/esm/cli/exec/info.d.ts

@@ -0,0 +1,3 @@
+import type { CommandExecutable } from "../executable.js";
+export declare const infoExec: CommandExecutable;
+//# sourceMappingURL=info.d.ts.map

package/esm/cli/exec/info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"info.d.ts","sourceRoot":"","sources":["../../../src/cli/exec/info.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAG1D,eAAO,MAAM,QAAQ,EAAE,iBAgBtB,CAAC"}

package/esm/cli/exec/info.js

@@ -0,0 +1,18 @@
+import { runInfo } from "../../commands/info.js";
+export const infoExec = {
+    name: "info",
+    description: "Show resolved config and target",
+    async run(argv, runtime) {
+        if (argv.length > 1) {
+            runtime.output.stderr("info accepts at most one target argument\n");
+            return 1;
+        }
+        const target = argv.length > 0 ? argv[0] : undefined;
+        const result = await runInfo({ target }, runtime.output);
+        if (result.isErr()) {
+            runtime.output.stderr(String(result.Err()) + "\n");
+            return 1;
+        }
+        return 0;
+    },
+};

package/esm/cli/exec/login.d.ts

@@ -0,0 +1,3 @@
+import type { CommandExecutable } from "../executable.js";
+export declare const loginExec: CommandExecutable;
+//# sourceMappingURL=login.d.ts.map

package/esm/cli/exec/login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../../src/cli/exec/login.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAsB1D,eAAO,MAAM,SAAS,EAAE,iBAYvB,CAAC"}

package/esm/cli/exec/login.js

@@ -0,0 +1,32 @@
+import { runLogin } from "../../commands/login.js";
+function parseArgs(argv) {
+    let caUrl;
+    let timeout = 120;
+    let forceRenew = false;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--ca-url" && i + 1 < argv.length) {
+            caUrl = argv[++i];
+        }
+        else if (arg === "--timeout" && i + 1 < argv.length) {
+            timeout = parseInt(argv[++i], 10);
+        }
+        else if (arg === "--force-renew") {
+            forceRenew = true;
+        }
+    }
+    return { caUrl, timeout, forceRenew };
+}
+export const loginExec = {
+    name: "login",
+    description: "Authenticate with vibes.diy",
+    async run(argv, runtime) {
+        const args = parseArgs(argv);
+        const result = await runLogin(args, runtime.output, runtime.loginPlatform);
+        if (result.isErr()) {
+            runtime.output.stderr(String(result.Err()) + "\n");
+            return 1;
+        }
+        return 0;
+    },
+};

package/esm/cli/exec/skills.d.ts

@@ -0,0 +1,3 @@
+import type { CommandExecutable } from "../executable.js";
+export declare const skillsExec: CommandExecutable;
+//# sourceMappingURL=skills.d.ts.map

package/esm/cli/exec/skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../../../src/cli/exec/skills.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAG1D,eAAO,MAAM,UAAU,EAAE,iBAWxB,CAAC"}

package/esm/cli/exec/skills.js

@@ -0,0 +1,13 @@
+import { runSkills } from "../../commands/skills.js";
+export const skillsExec = {
+    name: "skills",
+    description: "List available skills",
+    async run(_argv, runtime) {
+        const result = await runSkills(runtime.output);
+        if (result.isErr()) {
+            runtime.output.stderr(String(result.Err()) + "\n");
+            return 1;
+        }
+        return 0;
+    },
+};

package/esm/cli/exec/system.d.ts

@@ -0,0 +1,3 @@
+import type { CommandExecutable } from "../executable.js";
+export declare const systemExec: CommandExecutable;
+//# sourceMappingURL=system.d.ts.map

package/esm/cli/exec/system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../../src/cli/exec/system.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAG1D,eAAO,MAAM,UAAU,EAAE,iBAsBxB,CAAC"}

package/esm/cli/exec/system.js

@@ -0,0 +1,23 @@
+import { runSystem } from "../../commands/system.js";
+export const systemExec = {
+    name: "system",
+    description: "Emit system prompt",
+    async run(argv, runtime) {
+        let skillsCsv;
+        for (let i = 0; i < argv.length; i++) {
+            if (argv[i] === "--skills" && i + 1 < argv.length) {
+                skillsCsv = argv[++i];
+            }
+            else if (argv[i] === "--skills") {
+                // --skills with no value: fall back to defaults
+                skillsCsv = undefined;
+            }
+        }
+        const result = await runSystem({ skillsCsv }, runtime.output);
+        if (result.isErr()) {
+            runtime.output.stderr(String(result.Err()) + "\n");
+            return 1;
+        }
+        return 0;
+    },
+};

package/esm/cli/exec/whoami.d.ts

@@ -0,0 +1,3 @@
+import type { CommandExecutable } from "../executable.js";
+export declare const whoamiExec: CommandExecutable;
+//# sourceMappingURL=whoami.d.ts.map

package/esm/cli/exec/whoami.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whoami.d.ts","sourceRoot":"","sources":["../../../src/cli/exec/whoami.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAG1D,eAAO,MAAM,UAAU,EAAE,iBAWxB,CAAC"}

package/esm/cli/exec/whoami.js

@@ -0,0 +1,13 @@
+import { runWhoami } from "../../commands/whoami.js";
+export const whoamiExec = {
+    name: "whoami",
+    description: "Print device identity and linked handles",
+    async run(_argv, runtime) {
+        const result = await runWhoami(runtime.output);
+        if (result.isErr()) {
+            runtime.output.stderr(String(result.Err()) + "\n");
+            return 1;
+        }
+        return 0;
+    },
+};

package/esm/cli/executable.d.ts

@@ -0,0 +1,13 @@
+import type { CliOutput } from "../commands/cli-output.js";
+import type { LoginPlatform } from "../commands/login.js";
+export interface CliRuntime {
+    readonly output: CliOutput;
+    readonly setExitCode: (code: number) => void;
+    readonly loginPlatform: LoginPlatform;
+}
+export interface CommandExecutable {
+    readonly name: string;
+    readonly description: string;
+    run(argv: string[], runtime: CliRuntime): Promise<number>;
+}
+//# sourceMappingURL=executable.d.ts.map

package/esm/cli/executable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executable.d.ts","sourceRoot":"","sources":["../../src/cli/executable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7C,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;CACvC;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC3D"}

package/esm/cli/executable.js

@@ -0,0 +1 @@
+export {};

package/esm/commands/cli-output.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli-output.d.ts","sourceRoot":"","sources":["../../src/commands/cli-output.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC;AAED,eAAO,MAAM,gBAAgB,EAAE,SAG9B,CAAC"}
+{"version":3,"file":"cli-output.d.ts","sourceRoot":"","sources":["../../src/commands/cli-output.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC;AAID,eAAO,MAAM,gBAAgB,EAAE,SAG9B,CAAC"}

package/esm/commands/cli-output.js

@@ -1,3 +1,4 @@
+import process from "node:process";
 export const defaultCliOutput = {
     stdout: (text) => process.stdout.write(text),
     stderr: (text) => process.stderr.write(text),

package/esm/commands/config.d.ts

@@ -0,0 +1,13 @@
+import { Result } from "@adviser/cement";
+declare const VibesJsonType: import("arktype/internal/variants/object.ts").ObjectType<{
+    app: string;
+    targets?: Record<string, unknown> | undefined;
+}, {}>;
+export type VibesConfig = typeof VibesJsonType.infer;
+export interface FoundConfig {
+    readonly path: string;
+    readonly config: VibesConfig;
+}
+export declare function findVibesJson(startDir: string): Promise<Result<FoundConfig>>;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/esm/commands/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/commands/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAoB,MAAM,iBAAiB,CAAC;AAG3D,QAAA,MAAM,aAAa;;;MAGjB,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,OAAO,aAAa,CAAC,KAAK,CAAC;AAErD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;CAC9B;AAED,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CA+BlF"}

package/esm/commands/config.js

@@ -0,0 +1,36 @@
+import { readFile } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { Result, exception2Result } from "@adviser/cement";
+import { type } from "arktype";
+const VibesJsonType = type({
+    app: "string > 0",
+    "targets?": "Record<string, unknown>",
+});
+export async function findVibesJson(startDir) {
+    let dir = startDir;
+    for (;;) {
+        const candidate = join(dir, "vibes.json");
+        const readResult = await exception2Result(() => readFile(candidate, "utf-8"));
+        if (readResult.isErr()) {
+            const err = readResult.Err();
+            if (typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT") {
+                const parent = dirname(dir);
+                if (parent === dir) {
+                    return Result.Err("No vibes.json found (searched up to filesystem root)");
+                }
+                dir = parent;
+                continue;
+            }
+            return Result.Err(`Error reading ${candidate}: ${err}`);
+        }
+        const parseResult = exception2Result(() => JSON.parse(readResult.Ok()));
+        if (parseResult.isErr()) {
+            return Result.Err(`Invalid JSON in ${candidate}: ${parseResult.Err()}`);
+        }
+        const validated = VibesJsonType(parseResult.Ok());
+        if (validated instanceof type.errors) {
+            return Result.Err(`Invalid vibes.json at ${candidate}: ${validated.summary}`);
+        }
+        return Result.Ok({ path: candidate, config: validated });
+    }
+}

package/esm/commands/handle-register.d.ts

@@ -0,0 +1,19 @@
+import { Result } from "@adviser/cement";
+import type { CliOutput } from "./cli-output.js";
+import type { ReqRegisterHandle, ResRegisterHandle } from "@vibes.diy/api-types";
+export interface RunRegisterHandleOptions {
+    readonly slug?: string;
+}
+export interface RegisterHandleDeps {
+    readonly api?: RegisterHandleApi;
+}
+export interface RegisterHandleResultLike {
+    isErr(): boolean;
+    Err(): unknown;
+    Ok(): ResRegisterHandle;
+}
+export interface RegisterHandleApi {
+    registerHandle(req: Omit<ReqRegisterHandle, "type" | "auth">): Promise<RegisterHandleResultLike>;
+}
+export declare function runRegisterHandle(options: RunRegisterHandleOptions, output: CliOutput, deps?: RegisterHandleDeps): Promise<Result<void>>;
+//# sourceMappingURL=handle-register.d.ts.map

package/esm/commands/handle-register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-register.d.ts","sourceRoot":"","sources":["../../src/commands/handle-register.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAEjF,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,GAAG,CAAC,EAAE,iBAAiB,CAAC;CAClC;AAED,MAAM,WAAW,wBAAwB;IACvC,KAAK,IAAI,OAAO,CAAC;IACjB,GAAG,IAAI,OAAO,CAAC;IACf,EAAE,IAAI,iBAAiB,CAAC;CACzB;AAED,MAAM,WAAW,iBAAiB;IAChC,cAAc,CAAC,GAAG,EAAE,IAAI,CAAC,iBAAiB,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;CAClG;AA0CD,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,wBAAwB,EACjC,MAAM,EAAE,SAAS,EACjB,IAAI,GAAE,kBAAuB,GAC5B,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAgCvB"}

package/esm/commands/handle-register.js

@@ -0,0 +1,65 @@
+import { Result } from "@adviser/cement";
+import { createCliVibesApi, getCliDashAuth } from "./vibes-api.js";
+function hasMessage(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    if (!("message" in value)) {
+        return false;
+    }
+    return typeof Reflect.get(value, "message") === "string";
+}
+function toErrorMessage(error) {
+    if (typeof error === "string") {
+        return error;
+    }
+    if (hasMessage(error)) {
+        return error.message;
+    }
+    return String(error);
+}
+function toRegisterReq(slug) {
+    if (typeof slug === "undefined") {
+        return Result.Ok({});
+    }
+    const trimmed = slug.trim();
+    if (trimmed.length === 0) {
+        return Result.Err("Handle slug must not be empty");
+    }
+    const withoutAt = trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+    if (withoutAt.length === 0) {
+        return Result.Err("Handle slug must not be empty");
+    }
+    return Result.Ok({ userSlug: withoutAt });
+}
+function emitRegistered(output, registered) {
+    output.stdout(`handle:     @${registered.userSlug}\n`);
+    output.stdout(`created:    ${registered.created}\n`);
+}
+export async function runRegisterHandle(options, output, deps = {}) {
+    const rReq = toRegisterReq(options.slug);
+    if (rReq.isErr()) {
+        return Result.Err(rReq.Err());
+    }
+    const api = await (async function resolveApi() {
+        if (deps.api) {
+            return Result.Ok(deps.api);
+        }
+        const rAuth = await getCliDashAuth();
+        if (rAuth.isErr()) {
+            return Result.Err(toErrorMessage(rAuth.Err()));
+        }
+        return Result.Ok(createCliVibesApi({
+            getToken: () => Promise.resolve(rAuth),
+        }));
+    })();
+    if (api.isErr()) {
+        return Result.Err(api.Err());
+    }
+    const rRegistered = await api.Ok().registerHandle(rReq.Ok());
+    if (rRegistered.isErr()) {
+        return Result.Err(toErrorMessage(rRegistered.Err()));
+    }
+    emitRegistered(output, rRegistered.Ok());
+    return Result.Ok(undefined);
+}

package/esm/commands/info.d.ts

@@ -0,0 +1,8 @@
+import { Result } from "@adviser/cement";
+import type { CliOutput } from "./cli-output.js";
+export interface RunInfoOptions {
+    readonly target?: string;
+    readonly startDir?: string;
+}
+export declare function runInfo(opts: RunInfoOptions, output: CliOutput): Promise<Result<void>>;
+//# sourceMappingURL=info.d.ts.map

package/esm/commands/info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"info.d.ts","sourceRoot":"","sources":["../../src/commands/info.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAIjD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,wBAAsB,OAAO,CAAC,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAoB5F"}

package/esm/commands/info.js

@@ -0,0 +1,25 @@
+import { cwd } from "node:process";
+import { Result } from "@adviser/cement";
+import { findVibesJson } from "./config.js";
+import { resolveTarget } from "./resolve-target.js";
+export async function runInfo(opts, output) {
+    const startDir = opts.startDir ?? cwd();
+    const found = await findVibesJson(startDir);
+    if (found.isErr())
+        return Result.Err(found.Err());
+    const { path, config } = found.Ok();
+    output.stdout(`vibes.json: ${path}\n`);
+    output.stdout(`app:        ${config.app}\n`);
+    // Only resolve fully-qualified targets (owner/app/group) without auth.
+    // Bare targets need an owner from login, which isn't implemented yet.
+    if (opts.target && opts.target.includes("/")) {
+        const resolved = resolveTarget({ app: config.app, handle: "" }, opts.target);
+        if (resolved.isErr())
+            return Result.Err(resolved.Err());
+        output.stdout(`target:     ${resolved.Ok().full}\n`);
+    }
+    else if (opts.target) {
+        output.stdout(`target:     (requires login to resolve "${opts.target}")\n`);
+    }
+    return Result.Ok(undefined);
+}

package/esm/commands/login-platform-node.d.ts

@@ -0,0 +1,3 @@
+import type { LoginPlatform } from "./login.js";
+export declare const nodeLoginPlatform: LoginPlatform;
+//# sourceMappingURL=login-platform-node.d.ts.map

package/esm/commands/login-platform-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login-platform-node.d.ts","sourceRoot":"","sources":["../../src/commands/login-platform-node.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAQhD,eAAO,MAAM,iBAAiB,EAAE,aA8C/B,CAAC"}

package/esm/commands/login-platform-node.js

@@ -0,0 +1,56 @@
+import { createServer } from "node:http";
+import { execFile } from "node:child_process";
+import { env, platform } from "node:process";
+function closeServer(server) {
+    return new Promise((resolve, reject) => {
+        server.close((err) => (err ? reject(err) : resolve()));
+    });
+}
+export const nodeLoginPlatform = {
+    serve(opts, handler) {
+        let finishedResolve;
+        const finished = new Promise((r) => {
+            finishedResolve = r;
+        });
+        const server = createServer(async (req, res) => {
+            const url = new URL(req.url ?? "/", `http://${opts.hostname}:${opts.port}`);
+            const request = new Request(url.toString(), { method: req.method });
+            try {
+                const response = await handler(request);
+                res.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+                const body = await response.text();
+                res.end(body);
+            }
+            catch (err) {
+                res.writeHead(500);
+                res.end(err instanceof Error ? err.message : "Internal error");
+            }
+        });
+        server.on("error", () => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- assigned synchronously in Promise constructor
+            finishedResolve();
+        });
+        opts.signal.addEventListener("abort", () => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- assigned synchronously in Promise constructor
+            server.close(() => finishedResolve());
+        });
+        server.listen(opts.port, opts.hostname);
+        return {
+            close() {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- assigned synchronously in Promise constructor
+                closeServer(server).then(finishedResolve, finishedResolve);
+            },
+            finished,
+        };
+    },
+    async openBrowser(url) {
+        const cmd = platform === "win32" ? "cmd" : platform === "darwin" ? "open" : "xdg-open";
+        const args = platform === "win32" ? ["/c", "start", "", url] : [url];
+        await new Promise((resolve, reject) => {
+            execFile(cmd, args, (err) => (err ? reject(err) : resolve()));
+        });
+    },
+    getEnv(key) {
+        return env[key];
+    },
+};

package/esm/commands/login.d.ts

@@ -0,0 +1,22 @@
+import { Result } from "@adviser/cement";
+import type { CliOutput } from "./cli-output.js";
+export interface LoginServer {
+    close(): void;
+    readonly finished: Promise<void>;
+}
+export interface LoginPlatform {
+    readonly serve: (opts: {
+        port: number;
+        hostname: string;
+        signal: AbortSignal;
+    }, handler: (req: Request) => Response | Promise<Response>) => LoginServer;
+    readonly openBrowser: (url: string) => Promise<void>;
+    readonly getEnv: (key: string) => string | undefined;
+}
+export interface LoginOptions {
+    readonly caUrl?: string;
+    readonly timeout?: number;
+    readonly forceRenew?: boolean;
+}
+export declare function runLogin(options: LoginOptions, output: CliOutput, platform: LoginPlatform): Promise<Result<void>>;
+//# sourceMappingURL=login.d.ts.map

package/esm/commands/login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../src/commands/login.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAMzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAMjD,MAAM,WAAW,WAAW;IAC1B,KAAK,IAAI,IAAI,CAAC;IACd,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,CACd,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAE,EAC7D,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,KACpD,WAAW,CAAC;IACjB,QAAQ,CAAC,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CACtD;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,wBAAsB,QAAQ,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAoIvH"}

package/esm/commands/login.js

@@ -0,0 +1,127 @@
+import { Result } from "@adviser/cement";
+import { DeviceIdKey, DeviceIdCSR } from "@fireproof/core-device-id";
+import { getKeyBag } from "@fireproof/core-keybag";
+import { CertificatePayloadSchema } from "@fireproof/core-types-base";
+import { ensureSuperThis } from "@fireproof/core-runtime";
+import { decodeJwt } from "jose";
+const DEFAULT_CA_URL = "https://vibes.diy/csr2cert";
+const CA_URL_ENV = "VIBES_DIY_CA_URL";
+const DEFAULT_TIMEOUT_S = 120;
+export async function runLogin(options, output, platform) {
+    const sthis = ensureSuperThis();
+    const keyBag = await getKeyBag(sthis);
+    const existing = await keyBag.getDeviceId();
+    // Check if already registered
+    if (existing.cert.IsSome() && !options.forceRenew) {
+        const jwk = existing.deviceId.unwrap();
+        const deviceIdKey = (await DeviceIdKey.createFromJWK(jwk)).unwrap();
+        const fingerprint = await deviceIdKey.fingerPrint();
+        output.stdout(`Already registered. Device fingerprint: ${fingerprint}\n`);
+        output.stdout("Use --force-renew to renew the certificate.\n");
+        return Result.Ok(undefined);
+    }
+    // Step 1: Create or load device key
+    let deviceIdKey;
+    if (existing.deviceId.IsNone()) {
+        output.stdout("Creating device key pair...\n");
+        deviceIdKey = await DeviceIdKey.create();
+        const jwkPrivate = await deviceIdKey.exportPrivateJWK();
+        await keyBag.setDeviceId(jwkPrivate);
+    }
+    else {
+        const createResult = await DeviceIdKey.createFromJWK(existing.deviceId.unwrap());
+        if (createResult.isErr()) {
+            return Result.Err(`Failed to load device key: ${createResult.Err()}`);
+        }
+        deviceIdKey = createResult.Ok();
+    }
+    const fingerprint = await deviceIdKey.fingerPrint();
+    output.stdout(`Device fingerprint: ${fingerprint}\n`);
+    // Step 2: Generate CSR
+    output.stdout("Generating certificate signing request...\n");
+    const deviceIdCSR = new DeviceIdCSR(sthis, deviceIdKey);
+    const csrResult = await deviceIdCSR.createCSR({
+        commonName: `use-vibes-cli@${fingerprint}`,
+        organization: "vibes.diy",
+        locality: "SF",
+        stateOrProvinceName: "CA",
+        countryName: "US",
+    });
+    if (csrResult.isErr()) {
+        return Result.Err(`CSR generation failed: ${csrResult.Err()}`);
+    }
+    const csrJWS = csrResult.Ok();
+    // Step 3: Start localhost callback server
+    const state = crypto.randomUUID();
+    const port = Math.floor(Math.random() * (65535 - 49152) + 49152);
+    const callbackUrl = `http://127.0.0.1:${port}/cert`;
+    const timeoutMs = (options.timeout ?? DEFAULT_TIMEOUT_S) * 1000;
+    let certResolve;
+    const certPromise = new Promise((resolve, _reject) => {
+        certResolve = resolve;
+    });
+    const abortController = new AbortController();
+    const server = platform.serve({ port, hostname: "127.0.0.1", signal: abortController.signal }, (req) => {
+        const url = new URL(req.url);
+        if (url.pathname !== "/cert") {
+            return new Response("Not Found", { status: 404 });
+        }
+        const cert = url.searchParams.get("cert");
+        const returnedState = url.searchParams.get("state");
+        if (!cert) {
+            return new Response("Missing cert parameter", { status: 400 });
+        }
+        if (returnedState !== state) {
+            return new Response("State mismatch", { status: 403 });
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- assigned synchronously in Promise constructor
+        certResolve(cert);
+        return new Response("Certificate received. You can close this window.", {
+            headers: { "Content-Type": "text/plain" },
+        });
+    });
+    // Step 4: Open browser
+    const caUrl = options.caUrl ?? platform.getEnv(CA_URL_ENV) ?? DEFAULT_CA_URL;
+    const browserUrl = `${caUrl}?csr=${encodeURIComponent(csrJWS)}&returnUrl=${encodeURIComponent(callbackUrl)}&state=${encodeURIComponent(state)}`;
+    output.stdout(`\nOpen this URL in your browser to authorize:\n${browserUrl}\n\n`);
+    // Try to open browser automatically
+    try {
+        await platform.openBrowser(browserUrl);
+        output.stdout("Browser opened. Waiting for authorization...\n");
+    }
+    catch {
+        output.stdout("Waiting for authorization...\n");
+    }
+    // Step 5: Wait for certificate with timeout
+    let receivedCert;
+    try {
+        receivedCert = await Promise.race([
+            certPromise,
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout after ${options.timeout ?? DEFAULT_TIMEOUT_S}s`)), timeoutMs)),
+        ]);
+    }
+    catch (err) {
+        abortController.abort();
+        await server.finished;
+        return Result.Err(err instanceof Error ? err.message : "Login failed");
+    }
+    // Step 6: Shut down server immediately
+    server.close();
+    await server.finished;
+    // Step 7: Validate and store certificate
+    output.stdout("Certificate received. Storing...\n");
+    try {
+        const decoded = decodeJwt(receivedCert);
+        const certPayload = CertificatePayloadSchema.parse(decoded);
+        const jwkPrivate = await deviceIdKey.exportPrivateJWK();
+        await keyBag.setDeviceId(jwkPrivate, {
+            certificateJWT: receivedCert,
+            certificatePayload: certPayload,
+        });
+    }
+    catch (err) {
+        return Result.Err(`Failed to store certificate: ${err instanceof Error ? err.message : err}`);
+    }
+    output.stdout(`Login successful! Device fingerprint: ${fingerprint}\n`);
+    return Result.Ok(undefined);
+}

package/esm/commands/resolve-target.d.ts

@@ -0,0 +1,13 @@
+import { Result } from "@adviser/cement";
+export interface ResolvedTarget {
+    readonly handle: string;
+    readonly app: string;
+    readonly group: string;
+    readonly full: string;
+}
+export interface ResolveTargetContext {
+    readonly app: string;
+    readonly handle: string;
+}
+export declare function resolveTarget(ctx: ResolveTargetContext, input?: string): Result<ResolvedTarget>;
+//# sourceMappingURL=resolve-target.d.ts.map

package/esm/commands/resolve-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-target.d.ts","sourceRoot":"","sources":["../../src/commands/resolve-target.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,oBAAoB,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,cAAc,CAAC,CAgD/F"}

package/esm/commands/resolve-target.js

@@ -0,0 +1,42 @@
+import { Result } from "@adviser/cement";
+export function resolveTarget(ctx, input) {
+    const { app, handle } = ctx;
+    if (input === undefined) {
+        return Result.Ok({ handle, app, group: "default", full: `${handle}/${app}/default` });
+    }
+    if (input === "") {
+        return Result.Err("Target must not be empty");
+    }
+    if (input.startsWith("/") || input.endsWith("/")) {
+        return Result.Err(`Invalid target "${input}": must not start or end with /`);
+    }
+    const slashes = input.split("/").length - 1;
+    if (slashes === 0) {
+        return Result.Ok({ handle, app, group: input, full: `${handle}/${app}/${input}` });
+    }
+    if (slashes === 1) {
+        const [targetApp, targetGroup] = input.split("/");
+        if (targetApp === "" || targetGroup === "") {
+            return Result.Err(`Invalid target "${input}": app and group must both be non-empty`);
+        }
+        return Result.Ok({
+            handle,
+            app: targetApp,
+            group: targetGroup,
+            full: `${handle}/${targetApp}/${targetGroup}`,
+        });
+    }
+    if (slashes === 2) {
+        const [targetHandle, targetApp, targetGroup] = input.split("/");
+        if (targetHandle === "" || targetApp === "" || targetGroup === "") {
+            return Result.Err(`Invalid target "${input}": handle, app, and group must all be non-empty`);
+        }
+        return Result.Ok({
+            handle: targetHandle,
+            app: targetApp,
+            group: targetGroup,
+            full: input,
+        });
+    }
+    return Result.Err(`Invalid target "${input}": expected "group", "app/group", or "handle/app/group"`);
+}

package/esm/commands/vibes-api.d.ts

@@ -0,0 +1,15 @@
+import { Result } from "@adviser/cement";
+import { type VibesDiyApiParam } from "@vibes.diy/api-impl";
+import type { DashAuthType, VibesDiyApiIface } from "@vibes.diy/api-types";
+export interface CliVibesApiOptions {
+    readonly apiUrl?: string;
+    readonly getToken?: () => Promise<Result<DashAuthType>>;
+    readonly timeoutMs?: number;
+    readonly fetch?: VibesDiyApiParam["fetch"];
+    readonly ws?: WebSocket;
+}
+export declare function getCliVibesApiUrl(env?: Readonly<Record<string, string | undefined>>): string;
+export declare function getCliDashAuth(): Promise<Result<DashAuthType>>;
+export declare function toCliVibesApiParam(options?: CliVibesApiOptions): VibesDiyApiParam;
+export declare function createCliVibesApi(options?: CliVibesApiOptions): VibesDiyApiIface;
+//# sourceMappingURL=vibes-api.d.ts.map

package/esm/commands/vibes-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vibes-api.d.ts","sourceRoot":"","sources":["../../src/commands/vibes-api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAc,KAAK,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAS3E,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC;IACxD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAC3C,QAAQ,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC;CACzB;AAED,wBAAgB,iBAAiB,CAAC,GAAG,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAc,GAAG,MAAM,CAQxG;AAED,wBAAsB,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAyBpE;AAED,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,kBAAuB,GAAG,gBAAgB,CAQrF;AAED,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,kBAAuB,GAAG,gBAAgB,CAEpF"}

package/esm/commands/vibes-api.js

@@ -0,0 +1,51 @@
+import { Result } from "@adviser/cement";
+import { VibeDiyApi } from "@vibes.diy/api-impl";
+import { DeviceIdKey, DeviceIdSignMsg } from "@fireproof/core-device-id";
+import { getKeyBag } from "@fireproof/core-keybag";
+import { ensureSuperThis } from "@fireproof/core-runtime";
+import { env as processEnv } from "node:process";
+const DEFAULT_CLI_VIBES_API_URL = "wss://api.vibes.diy/v1/ws";
+const VIBES_API_URL_ENV = "VIBES_DIY_API_URL";
+export function getCliVibesApiUrl(env = processEnv) {
+    const envUrl = env[VIBES_API_URL_ENV];
+    switch (true) {
+        case typeof envUrl === "string" && envUrl.length > 0:
+            return envUrl;
+        default:
+            return DEFAULT_CLI_VIBES_API_URL;
+    }
+}
+export async function getCliDashAuth() {
+    const sthis = ensureSuperThis();
+    const keyBag = await getKeyBag(sthis);
+    const existing = await keyBag.getDeviceId();
+    if (existing.deviceId.IsNone() || existing.cert.IsNone()) {
+        return Result.Err("Not logged in. Run: use-vibes login");
+    }
+    const jwk = existing.deviceId.unwrap();
+    const createResult = await DeviceIdKey.createFromJWK(jwk);
+    if (createResult.isErr()) {
+        return Result.Err(`Failed to load device key: ${createResult.Err()}`);
+    }
+    const deviceIdKey = createResult.Ok();
+    const cert = existing.cert.unwrap();
+    if (!cert) {
+        return Result.Err("Not logged in. Run: use-vibes login");
+    }
+    const fingerprint = await deviceIdKey.fingerPrint();
+    const signer = new DeviceIdSignMsg(sthis.txt.base64, deviceIdKey, cert.certificatePayload);
+    const token = await signer.sign({ deviceId: fingerprint, seq: 0 });
+    return Result.Ok({ type: "device-id", token });
+}
+export function toCliVibesApiParam(options = {}) {
+    return {
+        apiUrl: options.apiUrl ?? getCliVibesApiUrl(),
+        getToken: options.getToken ?? getCliDashAuth,
+        timeoutMs: options.timeoutMs,
+        fetch: options.fetch,
+        ws: options.ws,
+    };
+}
+export function createCliVibesApi(options = {}) {
+    return new VibeDiyApi(toCliVibesApiParam(options));
+}

package/esm/commands/whoami.d.ts

@@ -1,3 +1,21 @@
 import { Result } from "@adviser/cement";
-export declare function runWhoami(): Promise<Result<void>>;
+import type { CliOutput } from "./cli-output.js";
+import type { ReqListUserSlugAppSlug, ResListUserSlugAppSlug } from "@vibes.diy/api-types";
+export interface WhoamiListResultLike {
+    isErr(): boolean;
+    Err(): unknown;
+    Ok(): ResListUserSlugAppSlug;
+}
+export interface WhoamiApi {
+    listUserSlugAppSlug(req: Omit<ReqListUserSlugAppSlug, "type" | "auth">): Promise<WhoamiListResultLike>;
+}
+export interface WhoamiDeviceInfo {
+    readonly fingerprint: string;
+    readonly certExpiry: Date | undefined;
+}
+export interface WhoamiDeps {
+    readonly api?: WhoamiApi;
+    readonly deviceInfo?: WhoamiDeviceInfo;
+}
+export declare function runWhoami(output: CliOutput, deps?: WhoamiDeps): Promise<Result<void>>;
 //# sourceMappingURL=whoami.d.ts.map

package/esm/commands/whoami.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"whoami.d.ts","sourceRoot":"","sources":["../../src/commands/whoami.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,wBAAsB,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAEvD"}
+{"version":3,"file":"whoami.d.ts","sourceRoot":"","sources":["../../src/commands/whoami.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAKzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,sBAAsB,EAAE,sBAAsB,EAAiB,MAAM,sBAAsB,CAAC;AAG1G,MAAM,WAAW,oBAAoB;IACnC,KAAK,IAAI,OAAO,CAAC;IACjB,GAAG,IAAI,OAAO,CAAC;IACf,EAAE,IAAI,sBAAsB,CAAC;CAC9B;AAED,MAAM,WAAW,SAAS;IACxB,mBAAmB,CAAC,GAAG,EAAE,IAAI,CAAC,sBAAsB,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;CACxG;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,IAAI,GAAG,SAAS,CAAC;CACvC;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,GAAG,CAAC,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,gBAAgB,CAAC;CACxC;AAqCD,wBAAsB,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,GAAE,UAAe,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CA4B/F"}

package/esm/commands/whoami.js

@@ -1,4 +1,102 @@
 import { Result } from "@adviser/cement";
-export async function runWhoami() {
-    return Result.Err("Not logged in. Run: use-vibes login");
+import { DeviceIdKey } from "@fireproof/core-device-id";
+import { getKeyBag } from "@fireproof/core-keybag";
+import { ensureSuperThis } from "@fireproof/core-runtime";
+import { decodeJwt } from "jose";
+import { createCliVibesApi, getCliDashAuth } from "./vibes-api.js";
+function hasCode(value) {
+    return typeof value === "object" && value !== null && "code" in value && typeof Reflect.get(value, "code") === "string";
+}
+async function loadDeviceInfo() {
+    const sthis = ensureSuperThis();
+    const keyBag = await getKeyBag(sthis);
+    const existing = await keyBag.getDeviceId();
+    if (existing.deviceId.IsNone()) {
+        return Result.Err("No device identity. Run: use-vibes login");
+    }
+    if (existing.cert.IsNone()) {
+        return Result.Err("Not registered. Run: use-vibes login");
+    }
+    const jwk = existing.deviceId.unwrap();
+    const createResult = await DeviceIdKey.createFromJWK(jwk);
+    if (createResult.isErr()) {
+        return Result.Err(`Failed to load device key: ${createResult.Err()}`);
+    }
+    const deviceIdKey = createResult.Ok();
+    const fingerprint = await deviceIdKey.fingerPrint();
+    const cert = existing.cert.unwrap();
+    if (!cert) {
+        return Result.Err("Not registered. Run: use-vibes login");
+    }
+    const decoded = decodeJwt(cert.certificateJWT);
+    const certExpiry = decoded.exp ? new Date(decoded.exp * 1000) : undefined;
+    return Result.Ok({ fingerprint, certExpiry });
+}
+export async function runWhoami(output, deps = {}) {
+    let deviceInfo;
+    if (deps.deviceInfo) {
+        deviceInfo = deps.deviceInfo;
+    }
+    else {
+        const rDevice = await loadDeviceInfo();
+        if (rDevice.isErr()) {
+            return Result.Err(rDevice.Err());
+        }
+        deviceInfo = rDevice.Ok();
+    }
+    // Fetch handles from API (non-fatal on failure)
+    await fetchAndPrintHandles(output, deps);
+    output.stdout(`Device: ${deviceInfo.fingerprint}\n`);
+    if (deviceInfo.certExpiry) {
+        const now = new Date();
+        if (deviceInfo.certExpiry < now) {
+            output.stdout(`Certificate: expired ${deviceInfo.certExpiry.toISOString()}\n`);
+        }
+        else {
+            output.stdout(`Certificate: valid until ${deviceInfo.certExpiry.toISOString()}\n`);
+        }
+    }
+    return Result.Ok(undefined);
+}
+async function fetchAndPrintHandles(output, deps) {
+    try {
+        const api = await resolveApi(deps);
+        if (!api) {
+            return;
+        }
+        const result = await api.listUserSlugAppSlug({});
+        if (result.isErr()) {
+            const err = result.Err();
+            if (hasCode(err) && err.code === "require-login") {
+                output.stderr("Session expired — run: use-vibes login\n");
+            }
+            else {
+                output.stderr("Could not reach API — handle info unavailable\n");
+            }
+            return;
+        }
+        const res = result.Ok();
+        if (res.items.length === 0) {
+            output.stdout("No handles linked\n");
+            return;
+        }
+        for (const item of res.items) {
+            output.stdout(`Handle: @${item.userSlug}\n`);
+        }
+    }
+    catch {
+        output.stderr("Could not reach API — handle info unavailable\n");
+    }
+}
+async function resolveApi(deps) {
+    if (deps.api) {
+        return deps.api;
+    }
+    const rAuth = await getCliDashAuth();
+    if (rAuth.isErr()) {
+        return undefined;
+    }
+    return createCliVibesApi({
+        getToken: () => Promise.resolve(rAuth),
+    });
 }

package/esm/dispatcher.d.ts

@@ -0,0 +1,5 @@
+import type { CliRuntime } from "./cli/executable.js";
+export type { CliRuntime } from "./cli/executable.js";
+export type { LoginPlatform } from "./commands/login.js";
+export declare function dispatch(cliArgs: readonly string[], runtime: CliRuntime): Promise<void>;
+//# sourceMappingURL=dispatcher.d.ts.map

package/esm/dispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatcher.d.ts","sourceRoot":"","sources":["../src/dispatcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqB,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAQzE,YAAY,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAazD,wBAAsB,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAmC7F"}

package/esm/dispatcher.js

@@ -0,0 +1,47 @@
+import { loginExec } from "./cli/exec/login.js";
+import { whoamiExec } from "./cli/exec/whoami.js";
+import { skillsExec } from "./cli/exec/skills.js";
+import { systemExec } from "./cli/exec/system.js";
+import { infoExec } from "./cli/exec/info.js";
+import { handleRegisterExec } from "./cli/exec/handle-register.js";
+const commands = [loginExec, whoamiExec, skillsExec, systemExec, infoExec, handleRegisterExec];
+function printHelp(output) {
+    output.stdout("use-vibes — Build and deploy React + Fireproof apps\n\n");
+    output.stdout("Commands:\n");
+    for (const cmd of commands) {
+        output.stdout(`  ${cmd.name.padEnd(18)}${cmd.description}\n`);
+    }
+    output.stdout("\nRun: use-vibes <command> --help\n");
+}
+export async function dispatch(cliArgs, runtime) {
+    if (cliArgs.length === 0 || cliArgs[0] === "help" || cliArgs[0] === "-h" || cliArgs[0] === "--help") {
+        printHelp(runtime.output);
+        return;
+    }
+    const token = cliArgs[0];
+    // Handle nested "handle register" command
+    if (token === "handle") {
+        if (cliArgs.length < 2 || cliArgs[1] === "--help" || cliArgs[1] === "-h") {
+            runtime.output.stdout("use-vibes handle — Manage handles\n\n");
+            runtime.output.stdout("Commands:\n");
+            runtime.output.stdout(`  register          ${handleRegisterExec.description}\n`);
+            return;
+        }
+        if (cliArgs[1] === "register") {
+            const code = await handleRegisterExec.run([...cliArgs.slice(2)], runtime);
+            runtime.setExitCode(code);
+            return;
+        }
+        runtime.output.stderr(`Unknown handle subcommand: ${cliArgs[1]}\n`);
+        runtime.setExitCode(1);
+        return;
+    }
+    const exec = commands.find((c) => c.name === token);
+    if (!exec) {
+        runtime.output.stderr(`Unknown command: ${token}\n`);
+        runtime.setExitCode(1);
+        return;
+    }
+    const code = await exec.run([...cliArgs.slice(1)], runtime);
+    runtime.setExitCode(code);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "use-vibes",
-  "version": "0.19.27-dev-cli",
+  "version": "0.19.29-dev-cli",
   "description": "Transform any DOM element into an AI-powered micro-app",
   "keywords": [
     "ai",
@@ -30,8 +30,7 @@
   "dependencies": {
     "@adviser/cement": "^0.5.32",
     "@vibes.diy/prompts": "*",
-    "@vibes.diy/use-vibes-base": "*",
-    "cmd-ts": "^0.15.0"
+    "@vibes.diy/use-vibes-base": "*"
   },
   "peerDependencies": {
     "react": ">=19.1.0"

package/esm/commands/not-implemented.d.ts

@@ -1,6 +0,0 @@
-import { Result } from "@adviser/cement";
-export interface NotImplementedOptions {
-    readonly name: string;
-}
-export declare function notImplemented(options: NotImplementedOptions): () => Promise<Result<void>>;
-//# sourceMappingURL=not-implemented.d.ts.map

package/esm/commands/not-implemented.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"not-implemented.d.ts","sourceRoot":"","sources":["../../src/commands/not-implemented.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,MAAM,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAI1F"}

package/esm/commands/not-implemented.js

@@ -1,6 +0,0 @@
-import { Result } from "@adviser/cement";
-export function notImplemented(options) {
-    return async function runNotImplemented() {
-        return Result.Err(`use-vibes ${options.name}: not yet implemented`);
-    };
-}

package/esm/run-cli.d.ts

@@ -1,7 +0,0 @@
-import type { CliOutput } from "./commands/cli-output.js";
-export interface CliRuntime {
-    readonly output: CliOutput;
-    readonly setExitCode: (code: number) => void;
-}
-export declare function runCli(cliArgs: readonly string[], runtime: CliRuntime): Promise<void>;
-//# sourceMappingURL=run-cli.d.ts.map

package/esm/run-cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-cli.d.ts","sourceRoot":"","sources":["../src/run-cli.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9C;AA+FD,wBAAsB,MAAM,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAiB3F"}

package/esm/run-cli.js

@@ -1,107 +0,0 @@
-import { command, option, run, runSafely, string, subcommands, restPositionals } from "cmd-ts";
-import { runWhoami } from "./commands/whoami.js";
-import { runSkills } from "./commands/skills.js";
-import { runSystem } from "./commands/system.js";
-import { notImplemented } from "./commands/not-implemented.js";
-async function emitResult(runtime, runner) {
-    const result = await runner();
-    if (result.isErr()) {
-        const err = result.Err();
-        runtime.output.stderr(typeof err === "string" ? err : String(err));
-        runtime.output.stderr("\n");
-        runtime.setExitCode(1);
-    }
-}
-async function emitGeneratedHelp(runtime, app) {
-    const result = await runSafely(app, ["--help"]);
-    if (result._tag === "ok") {
-        return;
-    }
-    const target = result.error.config.into === "stdout" ? runtime.output.stdout : runtime.output.stderr;
-    target(result.error.config.message);
-    if (result.error.config.message.endsWith("\n") === false) {
-        target("\n");
-    }
-    if (result.error.config.exitCode !== 0) {
-        runtime.setExitCode(result.error.config.exitCode);
-    }
-}
-function createStubCommand(runtime, name) {
-    return command({
-        name,
-        description: `${name} is not implemented yet`,
-        args: {
-            _rest: restPositionals({ description: "arguments" }),
-        },
-        handler: async function handleStub() {
-            await emitResult(runtime, notImplemented({ name }));
-        },
-    });
-}
-function createApp(runtime) {
-    const whoamiCmd = command({
-        name: "whoami",
-        description: "Print logged in user",
-        args: {},
-        handler: async function handleWhoami() {
-            await emitResult(runtime, runWhoami);
-        },
-    });
-    const skillsCmd = command({
-        name: "skills",
-        description: "List available skills",
-        args: {},
-        handler: async function handleSkills() {
-            await emitResult(runtime, () => runSkills(runtime.output));
-        },
-    });
-    const systemCmd = command({
-        name: "system",
-        description: "Emit system prompt",
-        args: {
-            skills: option({
-                type: string,
-                long: "skills",
-                description: "Comma-separated skills, e.g. fireproof,d3",
-                defaultValue: () => "",
-            }),
-        },
-        handler: async function handleSystem(args) {
-            const skillsCsv = args.skills.length > 0 ? args.skills : undefined;
-            await emitResult(runtime, () => runSystem({ skillsCsv }, runtime.output));
-        },
-    });
-    return subcommands({
-        name: "use-vibes",
-        description: "Build and deploy React + Fireproof apps",
-        cmds: {
-            whoami: whoamiCmd,
-            login: createStubCommand(runtime, "login"),
-            dev: createStubCommand(runtime, "dev"),
-            live: createStubCommand(runtime, "live"),
-            generate: createStubCommand(runtime, "generate"),
-            edit: createStubCommand(runtime, "edit"),
-            skills: skillsCmd,
-            system: systemCmd,
-            publish: createStubCommand(runtime, "publish"),
-            invite: createStubCommand(runtime, "invite"),
-        },
-    });
-}
-export async function runCli(cliArgs, runtime) {
-    const app = createApp(runtime);
-    switch (true) {
-        case cliArgs.length === 0:
-            await emitGeneratedHelp(runtime, app);
-            break;
-        case cliArgs.length === 1 && (cliArgs[0] === "-h" || cliArgs[0] === "--help"):
-            await emitGeneratedHelp(runtime, app);
-            break;
-        case cliArgs.length === 1 && cliArgs[0] === "help":
-            await emitGeneratedHelp(runtime, app);
-            break;
-        default:
-            await run(app, [...cliArgs]);
-            break;
-    }
-}