lazy-skill 0.0.1 → 0.1.1

package/dist/commands/disconnect.js

@@ -0,0 +1,30 @@
+import { api, ApiError } from "../lib/api.js";
+import { clearCredentials, readConfig } from "../lib/config.js";
+import { THEMES, style } from "../ui/theme.js";
+export async function disconnectCommand() {
+    const config = readConfig();
+    const theme = THEMES[config.theme];
+    if (!config.deviceToken) {
+        console.log(`\n  ${style.gray("Not connected. Nothing to disconnect.")}\n`);
+        return 0;
+    }
+    let serverMessage = "";
+    try {
+        await api("/api/cli/disconnect", { authed: true });
+    }
+    catch (err) {
+        // The local credential is cleared regardless. Leaving a token on disk
+        // because the network was down would be the worse failure.
+        serverMessage =
+            err instanceof ApiError
+                ? `Server not notified (${err.code}). Revoke the device from the app if needed.`
+                : "Server not notified.";
+    }
+    clearCredentials();
+    console.log(`\n  ${style.green("✓")} Disconnected. Theme kept.`);
+    if (serverMessage)
+        console.log(`  ${style.yellow("!")} ${serverMessage}`);
+    console.log(`  ${style.gray("Run")} npx lazy-skill connect ${style.gray("to pair again.")}\n`);
+    void theme;
+    return 0;
+}

package/dist/commands/install.js

@@ -0,0 +1,151 @@
+import { createInterface } from "node:readline/promises";
+import { readConfig } from "../lib/config.js";
+import { adapterFor, createInstallPlan, describePlan, detectAgents, InvalidPlanError, } from "../adapters/index.js";
+import { THEMES, rgb, style } from "../ui/theme.js";
+import { bottom, centered, mascot, row, top } from "../ui/box.js";
+import { messages } from "../ui/messages.js";
+const STAGE_LABEL = {
+    starting: "Preparing",
+    downloading: "Downloading",
+    installing: "Installing",
+    verifying: "Verifying",
+    done: "Done",
+    failed: "Failed",
+};
+const ORDER = ["downloading", "installing", "verifying"];
+function progressBar(theme, stage) {
+    const reached = ORDER.indexOf(stage);
+    return ORDER.map((step, i) => {
+        const filled = reached >= i;
+        const bar = filled ? "████" : "░░░░";
+        return `${filled ? rgb(theme.accent, bar) : style.gray(bar)}`;
+    }).join(" ");
+}
+async function confirm(question) {
+    if (!process.stdin.isTTY)
+        return false;
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = (await rl.question(`  ${question} [y/N] `)).trim().toLowerCase();
+        return answer === "y" || answer === "yes";
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * Installs a skill locally through the one supported pathway.
+ *
+ * The user is shown the exact command before anything runs (§23), and only
+ * agents actually detected on this machine are offered — installing "for
+ * Cursor" on a computer without Cursor would be a lie.
+ */
+export async function installCommand(ref, options = { yes: false }) {
+    const theme = THEMES[readConfig().theme];
+    if (!ref) {
+        console.error(`\n  ${style.red("✗")} Usage: lazy-skill install <owner/repo> [--agent claude]\n`);
+        return 1;
+    }
+    const detected = await detectAgents();
+    const available = detected.filter((agent) => agent.detected);
+    if (available.length === 0) {
+        console.error(`\n  ${style.yellow("!")} No supported AI tools were detected on this computer.`);
+        console.error(`  ${style.gray("Install Claude Code, Codex or Cursor first.")}\n`);
+        return 1;
+    }
+    const requested = options.agents
+        ? options.agents.split(",").map((a) => a.trim().toLowerCase()).filter(Boolean)
+        : available.map((a) => a.id);
+    const targets = [];
+    for (const id of requested) {
+        const adapter = adapterFor(id);
+        if (!adapter) {
+            console.error(`\n  ${style.red("✗")} Unknown agent "${id}".`);
+            console.error(`  ${style.gray("Known:")} ${detected.map((a) => a.id).join(", ")}\n`);
+            return 1;
+        }
+        // Refuse to claim an install for something that is not here (§13).
+        if (!available.some((a) => a.id === adapter.id)) {
+            console.error(`\n  ${style.red("✗")} ${adapter.label} was not detected on this computer.\n`);
+            return 1;
+        }
+        if (!targets.includes(adapter))
+            targets.push(adapter);
+    }
+    let plan;
+    try {
+        plan = createInstallPlan({
+            skillRef: ref,
+            agents: targets.map((t) => t.upstreamId),
+            scope: options.project ? "project" : "global",
+        });
+    }
+    catch (err) {
+        const message = err instanceof InvalidPlanError ? err.message : "That request is not valid.";
+        console.error(`\n  ${style.red("✗")} ${message}\n`);
+        return 1;
+    }
+    // Show exactly what will run, before it runs.
+    console.log();
+    console.log(top(theme));
+    console.log(row(theme));
+    console.log(row(theme, style.bold(`Install ${ref}`)));
+    console.log(row(theme, `for ${targets.map((t) => t.label).join(", ")}`));
+    console.log(row(theme, style.gray(options.project ? "scope: this project" : "scope: global")));
+    console.log(row(theme));
+    console.log(row(theme, style.gray("This will run:")));
+    console.log(row(theme, rgb(theme.accent, describePlan(plan).slice(0, 48))));
+    console.log(row(theme));
+    console.log(bottom(theme));
+    console.log();
+    if (!options.yes && !(await confirm("Continue?"))) {
+        console.log(`  ${style.gray("Cancelled. Nothing was installed.")}\n`);
+        return 1;
+    }
+    console.log();
+    let lastStage = "starting";
+    const onProgress = (progress) => {
+        if (progress.stage === lastStage)
+            return;
+        lastStage = progress.stage;
+        if (progress.stage === "done" || progress.stage === "failed")
+            return;
+        const label = STAGE_LABEL[progress.stage] ?? progress.stage;
+        console.log(`  ${label.padEnd(12)} ${progressBar(theme, progress.stage)}`);
+    };
+    // One adapter at a time, so a failure names the agent it belongs to.
+    const failures = [];
+    for (const adapter of targets) {
+        const outcome = await adapter.install(plan, onProgress);
+        if (!outcome.ok) {
+            failures.push(`${adapter.label}: ${outcome.error ?? "install failed"}`);
+        }
+        lastStage = "starting";
+    }
+    console.log();
+    if (failures.length > 0) {
+        console.log(`  ${style.red("✗")} ${messages.failed()}`);
+        for (const failure of failures)
+            console.log(`  ${style.gray(failure)}`);
+        console.log(`  ${style.gray("We haven't blamed you yet.")}\n`);
+        return 1;
+    }
+    console.log(top(theme));
+    console.log(row(theme));
+    for (const line of mascot(theme, true))
+        console.log(centered(theme, line));
+    console.log(row(theme));
+    console.log(centered(theme, rgb(theme.accent, style.bold("INSTALLED!"))));
+    console.log(row(theme));
+    console.log(row(theme, `${ref}`));
+    for (const target of targets) {
+        console.log(row(theme, `${target.label.padEnd(12)} ${style.green("✓")}`));
+    }
+    console.log(row(theme));
+    console.log(row(theme, `${style.gray("You contributed")}   ${style.bold("0% effort")}`));
+    console.log(row(theme, `${style.gray("Lazy Skill")}        ${rgb(theme.accent, "100% effort")}`));
+    console.log(row(theme));
+    console.log(bottom(theme));
+    console.log();
+    return 0;
+}

package/dist/commands/listen.js

@@ -0,0 +1,162 @@
+import { api, ApiError } from "../lib/api.js";
+import { readConfig } from "../lib/config.js";
+import { adapterFor, createInstallPlan, detectAgents, InvalidPlanError, } from "../adapters/index.js";
+import { isJobCommand, parseInstallPayload, UnsafeJobError } from "../lib/job-contract.js";
+import { THEMES, rgb, style } from "../ui/theme.js";
+import { messages } from "../ui/messages.js";
+const IDLE_POLL_MS = 3000;
+const ERROR_BACKOFF_MS = 15_000;
+function log(theme, line) {
+    const time = new Date().toLocaleTimeString();
+    console.log(`  ${style.gray(time)} ${line}`);
+    void theme;
+}
+async function report(jobId, body) {
+    try {
+        await api("/api/cli/jobs/progress", { authed: true, body: { jobId, ...body } });
+    }
+    catch {
+        // Progress is advisory. Losing a status update must not abort an install
+        // that is otherwise going fine.
+    }
+}
+/**
+ * Executes one job.
+ *
+ * Everything the server sent is re-validated here before anything runs. The
+ * server queues intent; this decides whether that intent is safe, and refuses
+ * it outright if not (§56).
+ */
+async function runJob(theme, job) {
+    if (!isJobCommand(job.command)) {
+        log(theme, `${style.red("✗")} refused unknown command "${String(job.command)}"`);
+        await report(job.id, { status: "failed", error: "Unknown command." });
+        return;
+    }
+    if (job.command !== "INSTALL_SKILL") {
+        // The other verbs are answered by the heartbeat rather than as jobs.
+        await report(job.id, { status: "succeeded", stage: "done" });
+        return;
+    }
+    let payload;
+    try {
+        payload = parseInstallPayload(job.payload);
+    }
+    catch (err) {
+        const message = err instanceof UnsafeJobError ? err.message : "Malformed job.";
+        log(theme, `${style.red("✗")} ${message}`);
+        await report(job.id, { status: "failed", error: message });
+        return;
+    }
+    // Only install to agents this machine actually has. The server checks too,
+    // but the device is the only party that really knows (§13).
+    const detected = (await detectAgents()).filter((a) => a.detected).map((a) => a.id);
+    const targets = payload.agents.filter((agent) => detected.includes(agent));
+    if (targets.length === 0) {
+        const message = "None of the requested tools are installed on this computer.";
+        log(theme, `${style.yellow("!")} ${message}`);
+        await report(job.id, { status: "failed", error: message, agents: payload.agents });
+        return;
+    }
+    log(theme, `${rgb(theme.accent, "▸")} installing ${style.bold(payload.skillName)}`);
+    await report(job.id, { status: "running", stage: "starting" });
+    const failures = [];
+    for (const agentId of targets) {
+        const adapter = adapterFor(agentId);
+        if (!adapter)
+            continue;
+        let plan;
+        try {
+            plan = createInstallPlan({
+                skillRef: payload.skillRef,
+                agents: [adapter.upstreamId],
+                scope: payload.scope,
+            });
+        }
+        catch (err) {
+            const message = err instanceof InvalidPlanError ? err.message : "Invalid plan.";
+            failures.push(`${adapter.label}: ${message}`);
+            await report(job.id, { status: "running", error: message, agents: [agentId] });
+            continue;
+        }
+        const onProgress = (progress) => {
+            if (progress.stage === "done" || progress.stage === "failed")
+                return;
+            void report(job.id, { status: "running", stage: progress.stage, agents: [agentId] });
+        };
+        const outcome = await adapter.install(plan, onProgress);
+        if (outcome.ok) {
+            log(theme, `  ${style.green("✓")} ${adapter.label}`);
+            await report(job.id, { status: "running", stage: "done", agents: [agentId] });
+        }
+        else {
+            const message = outcome.error ?? "Install failed.";
+            log(theme, `  ${style.red("✗")} ${adapter.label}: ${message}`);
+            failures.push(`${adapter.label}: ${message}`);
+            await report(job.id, { status: "running", stage: "failed", error: message, agents: [agentId] });
+        }
+    }
+    if (failures.length === targets.length) {
+        await report(job.id, { status: "failed", stage: "failed", error: failures.join("; ") });
+        log(theme, `${style.red("✗")} ${messages.failed()}`);
+    }
+    else {
+        await report(job.id, {
+            status: "succeeded",
+            stage: "done",
+            error: failures.length ? failures.join("; ") : undefined,
+        });
+        log(theme, `${style.green("✓")} done`);
+    }
+}
+/**
+ * Waits for work from the app.
+ *
+ * Polling rather than a socket: it survives sleep, captive portals and
+ * proxies, and there is nothing to reconnect. The device authenticates every
+ * request, so no long-lived connection is holding a credential open.
+ */
+export async function listenCommand(options = {}) {
+    const config = readConfig();
+    const theme = THEMES[config.theme];
+    if (!config.deviceToken) {
+        console.error(`\n  ${style.red("✗")} Not connected. Run ${style.bold("lazy-skill connect")} first.\n`);
+        return 1;
+    }
+    console.log();
+    console.log(`  ${rgb(theme.accent, "●")} ${style.bold("Listening")} for installs from your phone.`);
+    console.log(`  ${style.gray("Leave this running. Ctrl-C to stop.")}`);
+    console.log();
+    let stopped = false;
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        console.log(`\n  ${style.gray(messages.signOff())}\n`);
+        process.exit(0);
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+    let backoff = IDLE_POLL_MS;
+    while (!stopped) {
+        try {
+            const { job } = await api("/api/cli/jobs/claim", { authed: true });
+            backoff = IDLE_POLL_MS;
+            if (job)
+                await runJob(theme, job);
+        }
+        catch (err) {
+            if (err instanceof ApiError && (err.status === 401 || err.status === 403)) {
+                console.error(`\n  ${style.red("✗")} This computer was disconnected from the app.`);
+                console.error(`  ${style.gray("Run")} lazy-skill connect ${style.gray("to pair again.")}\n`);
+                return 1;
+            }
+            // Network blips are expected on a laptop. Back off rather than spinning.
+            backoff = Math.min(backoff * 2, ERROR_BACKOFF_MS);
+        }
+        if (options.once)
+            return 0;
+        await new Promise((resolve) => setTimeout(resolve, backoff));
+    }
+    return 0;
+}

package/dist/commands/skills.js

@@ -0,0 +1,74 @@
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homePath } from "../adapters/detect.js";
+import { detectAgents } from "../adapters/index.js";
+import { readConfig } from "../lib/config.js";
+import { THEMES, style } from "../ui/theme.js";
+import { bottom, centered, row, top, wordmark } from "../ui/box.js";
+/**
+ * Where each agent keeps installed skills. These are read-only lookups — the
+ * CLI lists what is on disk and never infers a skill that is not there.
+ */
+const SKILL_DIRS = {
+    claude: [homePath(".claude", "skills")],
+    codex: [homePath(".codex", "skills")],
+    cursor: [homePath(".cursor", "skills")],
+};
+function listSkillDirs(paths) {
+    const found = new Set();
+    for (const path of paths) {
+        try {
+            for (const entry of readdirSync(path)) {
+                if (entry.startsWith("."))
+                    continue;
+                try {
+                    if (statSync(join(path, entry)).isDirectory())
+                        found.add(entry);
+                }
+                catch {
+                    // Unreadable entry — skip rather than guess.
+                }
+            }
+        }
+        catch {
+            // Directory absent: the agent simply has no skills installed here.
+        }
+    }
+    return [...found].sort();
+}
+export async function skillsCommand() {
+    const theme = THEMES[readConfig().theme];
+    const agents = await detectAgents();
+    console.log();
+    console.log(top(theme));
+    console.log(row(theme));
+    for (const line of wordmark(theme))
+        console.log(centered(theme, line));
+    console.log(row(theme));
+    console.log(row(theme, style.bold("Installed skills on this computer")));
+    console.log(row(theme));
+    let total = 0;
+    for (const agent of agents) {
+        if (!agent.detected) {
+            console.log(row(theme, `${agent.label.padEnd(10)} ${style.gray("not detected")}`));
+            continue;
+        }
+        const skills = listSkillDirs(SKILL_DIRS[agent.id] ?? []);
+        total += skills.length;
+        console.log(row(theme, `${style.bold(agent.label.padEnd(10))} ${skills.length ? style.green(`${skills.length}`) : style.gray("none found")}`));
+        for (const skill of skills.slice(0, 20)) {
+            console.log(row(theme, style.gray(`  · ${skill}`)));
+        }
+        if (skills.length > 20) {
+            console.log(row(theme, style.gray(`  … and ${skills.length - 20} more`)));
+        }
+    }
+    console.log(row(theme));
+    if (total === 0) {
+        console.log(row(theme, style.gray("Nothing installed yet. You haven't been lazy enough.")));
+        console.log(row(theme));
+    }
+    console.log(bottom(theme));
+    console.log();
+    return 0;
+}

package/dist/commands/status.js

@@ -0,0 +1,55 @@
+import { api, ApiError } from "../lib/api.js";
+import { readConfig } from "../lib/config.js";
+import { detectAgents } from "../adapters/index.js";
+import { THEMES, style } from "../ui/theme.js";
+import { bottom, centered, row, statusLine, top, wordmark } from "../ui/box.js";
+export async function statusCommand() {
+    const config = readConfig();
+    const theme = THEMES[config.theme];
+    const agents = await detectAgents();
+    console.log();
+    console.log(top(theme));
+    console.log(row(theme));
+    for (const line of wordmark(theme))
+        console.log(centered(theme, line));
+    console.log(row(theme));
+    if (!config.deviceToken) {
+        console.log(row(theme, style.gray("Not connected.")));
+        console.log(row(theme));
+        console.log(row(theme, `Run ${style.bold("npx lazy-skill connect")}`));
+        console.log(row(theme));
+        console.log(bottom(theme));
+        console.log();
+        return 1;
+    }
+    // Detection is local and always shown. The server round trip only confirms
+    // the credential is still good, so a network failure downgrades the report
+    // rather than hiding what we do know.
+    let remote = null;
+    let remoteError = null;
+    try {
+        remote = await api("/api/cli/status", {
+            authed: true,
+            body: { detectedAgents: agents.filter((a) => a.detected).map((a) => a.id) },
+        });
+    }
+    catch (err) {
+        remoteError = err instanceof ApiError ? err.message : "Could not reach the server.";
+    }
+    console.log(row(theme, `${style.bold(config.deviceName ?? "This computer")}`));
+    console.log(row(theme, remote
+        ? `${style.green("●")} Connected`
+        : `${style.yellow("●")} Credential stored, server unreachable`));
+    console.log(row(theme));
+    for (const agent of agents) {
+        console.log(row(theme, statusLine(agent.label, agent.detected ? true : null)));
+    }
+    console.log(row(theme));
+    console.log(bottom(theme));
+    if (remoteError) {
+        console.log();
+        console.log(`  ${style.gray(remoteError)}`);
+    }
+    console.log();
+    return 0;
+}

package/dist/commands/theme.js

@@ -0,0 +1,50 @@
+import { createInterface } from "node:readline/promises";
+import { readConfig, updateConfig } from "../lib/config.js";
+import { THEMES, THEME_IDS, rgb, style } from "../ui/theme.js";
+/**
+ * Theme picker. The choice is stored locally and travels with the next
+ * pairing so the phone adopts the same look.
+ */
+export async function themeCommand(requested) {
+    const current = readConfig().theme;
+    if (requested) {
+        const match = THEME_IDS.find((id) => id === requested);
+        if (!match) {
+            console.error(`\n  ${style.red("✗")} Unknown theme "${requested}".`);
+            console.error(`  ${style.gray("Options:")} ${THEME_IDS.join(", ")}\n`);
+            return 1;
+        }
+        updateConfig({ theme: match });
+        console.log(`\n  ${style.green("✓")} Theme set to ${rgb(THEMES[match].accent, THEMES[match].label)}.\n`);
+        return 0;
+    }
+    console.log(`\n  ${style.bold("Pick a theme")}\n`);
+    THEME_IDS.forEach((id, i) => {
+        const t = THEMES[id];
+        const marker = id === current ? style.green("●") : style.gray("○");
+        console.log(`  ${marker} ${i + 1}. ${rgb(t.accent, "████")} ${t.label}`);
+    });
+    console.log();
+    if (!process.stdin.isTTY) {
+        console.log(`  ${style.gray("Not a terminal — pass a theme id instead, e.g. lazy-skill theme matrix-green")}\n`);
+        return 0;
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = (await rl.question("  Number (enter to keep current): ")).trim();
+        if (!answer)
+            return 0;
+        const index = Number(answer) - 1;
+        if (!Number.isInteger(index) || index < 0 || index >= THEME_IDS.length) {
+            console.log(`\n  ${style.yellow("!")} Not one of the options. Theme unchanged.\n`);
+            return 1;
+        }
+        const chosen = THEME_IDS[index];
+        updateConfig({ theme: chosen });
+        console.log(`\n  ${style.green("✓")} Theme set to ${rgb(THEMES[chosen].accent, THEMES[chosen].label)}.\n`);
+        return 0;
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/index.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import { readConfig } from "./lib/config.js";
+import { THEMES, rgb, style } from "./ui/theme.js";
+import { connectCommand } from "./commands/connect.js";
+import { disconnectCommand } from "./commands/disconnect.js";
+import { statusCommand } from "./commands/status.js";
+import { skillsCommand } from "./commands/skills.js";
+import { installCommand } from "./commands/install.js";
+import { themeCommand } from "./commands/theme.js";
+import { listenCommand } from "./commands/listen.js";
+const VERSION = "0.1.0";
+function help() {
+    const theme = THEMES[readConfig().theme];
+    const cmd = (name) => rgb(theme.accent, name.padEnd(24));
+    console.log(`
+  ${style.bold("LAZY")} ${rgb(theme.accent, style.bold("SKILL"))}${rgb(theme.support, " Zz")}   ${style.gray("See it. Search it. Install it.")}
+
+  ${style.bold("Usage")}
+    ${cmd("lazy-skill connect")}Pair, then wait for installs
+    ${cmd("lazy-skill listen")}Wait for installs sent from your phone
+    ${cmd("lazy-skill status")}Show connection and detected tools
+    ${cmd("lazy-skill skills")}List skills installed on this computer
+    ${cmd("lazy-skill disconnect")}Revoke this computer
+    ${cmd("lazy-skill theme [id]")}Pick a colour theme
+    ${cmd("lazy-skill install <ref>")}Install a skill locally
+
+  ${style.bold("Options")}
+    ${cmd("--agent=<ids>")}Comma-separated agents to install to
+    ${cmd("--no-listen")}Pair only; do not wait for installs
+    ${cmd("-p, --project")}Install into this project, not globally
+    ${cmd("-y, --yes")}Skip the confirmation prompt
+    ${cmd("-v, --verbose")}Show how each tool was detected
+    ${cmd("-h, --help")}This
+    ${cmd("--version")}Print the version
+
+  ${style.gray("Config:")} ~/.lazyskill/config.json
+  ${style.gray("Server:")} set LAZY_SKILL_API_URL to point at a different host
+`);
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    const flags = new Set(argv.filter((a) => a.startsWith("-")));
+    const positional = argv.filter((a) => !a.startsWith("-"));
+    const command = positional[0];
+    if (flags.has("--version")) {
+        console.log(VERSION);
+        return 0;
+    }
+    if (!command || flags.has("-h") || flags.has("--help") || command === "help") {
+        help();
+        return 0;
+    }
+    const verbose = flags.has("-v") || flags.has("--verbose");
+    switch (command) {
+        case "connect":
+            return connectCommand({
+                verbose,
+                // Listening is the default; --no-listen opts out.
+                listen: flags.has("--no-listen") ? false : true,
+            });
+        case "disconnect":
+            return disconnectCommand();
+        case "status":
+            return statusCommand();
+        case "listen":
+            return listenCommand({ once: flags.has("--once") });
+        case "skills":
+            return skillsCommand();
+        case "theme":
+            return themeCommand(positional[1]);
+        case "install": {
+            const agentFlag = argv.find((a) => a.startsWith("--agent="))?.split("=")[1];
+            const yes = flags.has("-y") || flags.has("--yes");
+            const project = flags.has("-p") || flags.has("--project");
+            return installCommand(positional[1], { agents: agentFlag, yes, project });
+        }
+        default:
+            console.error(`\n  ${style.red("✗")} Unknown command "${command}".\n`);
+            help();
+            return 1;
+    }
+}
+main()
+    .then((code) => process.exit(code))
+    .catch((err) => {
+    // Never dump a stack at a user who just wanted to install something.
+    console.error(`\n  ${style.red("✗")} ${err?.message ?? "Something went wrong."}\n`);
+    process.exit(1);
+});

package/dist/lib/api.js

@@ -0,0 +1,63 @@
+import { apiBaseUrl, readConfig } from "./config.js";
+export class ApiError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "ApiError";
+    }
+}
+/**
+ * Talks to the Lazy Skill server. Every call is explicit about whether it
+ * carries the device token, so the credential is never sent to an endpoint
+ * that does not need it.
+ */
+export async function api(path, options = {}) {
+    const { body, authed = false, timeoutMs = 15_000 } = options;
+    const headers = { "Content-Type": "application/json" };
+    if (authed) {
+        const token = readConfig().deviceToken;
+        if (!token) {
+            throw new ApiError(401, "not_connected", "This computer is not connected yet.");
+        }
+        headers.Authorization = `Bearer ${token}`;
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(`${apiBaseUrl()}${path}`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body ?? {}),
+            signal: controller.signal,
+        });
+        const text = await res.text();
+        const parsed = text ? safeJson(text) : null;
+        if (!res.ok) {
+            const err = parsed;
+            throw new ApiError(res.status, err?.error ?? "http_error", err?.message ?? `Server returned ${res.status}.`);
+        }
+        return parsed;
+    }
+    catch (err) {
+        if (err instanceof ApiError)
+            throw err;
+        if (err.name === "AbortError") {
+            throw new ApiError(0, "timeout", "The server took too long to answer.");
+        }
+        throw new ApiError(0, "network", `Could not reach ${apiBaseUrl()}.`);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}