@skrr-ai/cli 0.1.87 → 0.1.89

package/dist/lib/agent-home-workspace.js

@@ -1,8 +1,45 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyAgentHomeWorkspaceDefault = applyAgentHomeWorkspaceDefault;
 exports.lookupAgentHomeWorkspaceDefault = lookupAgentHomeWorkspaceDefault;
 exports.commitAgentHomeWorkspaceDefault = commitAgentHomeWorkspaceDefault;
+exports.serverAppliesAgentHomeDefault = serverAppliesAgentHomeDefault;
+exports.recordAgentHomeDefaultObservation = recordAgentHomeDefaultObservation;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
 /**
  * The workspace an `agents chat` turn runs in when the caller named none.
  *
@@ -64,3 +101,113 @@ function commitAgentHomeWorkspaceDefault(workspaceId, env = process.env) {
     env.OVERSKY_WORKSPACE_ID = workspaceId;
     return workspaceId;
 }
+/**
+ * OSK-13599 — whether the server this CLI talks to chooses the agent-home
+ * workspace itself.
+ *
+ * A server that does (it defaults a headerless `POST /api/agentic/chat` to the
+ * agent's CURRENT home workspace, under exactly the checks the header would
+ * pass) makes the pre-flight agent read above redundant, and that read is a
+ * full round trip (~480ms at production RTT) on every turn.
+ *
+ * What is remembered is a fact about the SERVER, never the agent's workspace:
+ * agents move between workspaces, so caching their workspace could start a turn
+ * in the wrong one, while "this origin applies the default" stays true until
+ * the server is rolled back. The evidence is the acceptance itself — a server
+ * that applies the default always answers with a `workspaceSource` key (null
+ * included); an older one never does. So:
+ *
+ *   - first turn against an origin: no observation → the agent read happens,
+ *     exactly as before; the acceptance records the observation;
+ *   - later turns: the read is skipped and the server chooses;
+ *   - a rollback: the acceptance lacks the key, the observation is dropped and
+ *     the NEXT turn reads again. The one turn in between ran with no workspace
+ *     (the pre-OSK-9937 behaviour), which the command reports on stderr.
+ *
+ * Best-effort everywhere: an unreadable or unwritable cache is "not observed",
+ * which is today's behaviour, never an error.
+ */
+const SERVER_FEATURES_FILE = 'server-features.json';
+/** Re-confirm at most this often, so a supported server is not a write per turn. */
+const OBSERVATION_REFRESH_MS = 24 * 60 * 60 * 1000;
+/** An observation nobody has re-confirmed for this long is not trusted. */
+const OBSERVATION_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+function originOf(baseURL) {
+    try {
+        return new URL(baseURL).origin;
+    }
+    catch {
+        return null;
+    }
+}
+function featuresPath(cacheDir) {
+    return path.join(cacheDir, SERVER_FEATURES_FILE);
+}
+function readFeatures(cacheDir) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(featuresPath(cacheDir), 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Does this origin's server default a headerless chat turn's workspace itself? */
+function serverAppliesAgentHomeDefault(cacheDir, baseURL, now = Date.now()) {
+    if (!cacheDir || !baseURL)
+        return false;
+    const origin = originOf(baseURL);
+    if (!origin)
+        return false;
+    const seen = readFeatures(cacheDir)[origin];
+    if (seen?.agentHomeWorkspaceDefault !== true)
+        return false;
+    const at = Date.parse(seen.observedAt);
+    return Number.isFinite(at) && now - at <= OBSERVATION_MAX_AGE_MS;
+}
+/**
+ * Record what an acceptance says about the server, and return it. Writes only
+ * when the verdict changes or the observation is getting old.
+ */
+function recordAgentHomeDefaultObservation(cacheDir, baseURL, accepted, now = Date.now()) {
+    const supported = !!accepted && typeof accepted === 'object' && 'workspaceSource' in accepted;
+    const verdict = supported ? 'supported' : 'unsupported';
+    if (!cacheDir || !baseURL)
+        return verdict;
+    const origin = originOf(baseURL);
+    if (!origin)
+        return verdict;
+    try {
+        const features = readFeatures(cacheDir);
+        const previous = features[origin];
+        if (!supported && !previous)
+            return verdict;
+        const previousAt = previous ? Date.parse(previous.observedAt) : NaN;
+        if (supported &&
+            previous?.agentHomeWorkspaceDefault === true &&
+            Number.isFinite(previousAt) &&
+            now - previousAt < OBSERVATION_REFRESH_MS) {
+            return verdict;
+        }
+        if (supported) {
+            features[origin] = {
+                agentHomeWorkspaceDefault: true,
+                observedAt: new Date(now).toISOString(),
+            };
+        }
+        else {
+            delete features[origin];
+        }
+        fs.mkdirSync(cacheDir, { recursive: true, mode: 0o700 });
+        const file = featuresPath(cacheDir);
+        const tmp = `${file}.${process.pid}.${now}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(features), { mode: 0o600 });
+        fs.renameSync(tmp, file);
+    }
+    catch {
+        // Best-effort: the next turn simply reads the agent again.
+    }
+    return verdict;
+}

package/dist/lib/computer-adoption.d.ts

@@ -0,0 +1,60 @@
+/** One window's counts, for all daemons and for field daemons (not Dedicated Runtime guests). */
+export interface ComputerAdoptionCounts {
+    active: number;
+    computerOnly: number;
+    both: number;
+    legacyOnly: number;
+    neither: number;
+    legacyOnlyShare: number | null;
+    announcingOldShare: number | null;
+}
+/** One client build that opened a `browser:liveview:*` view inside the window (OSK-13616). */
+export interface ComputerLiveViewClient {
+    platform: string;
+    os: string;
+    version: string;
+    lastSeenAt: string;
+}
+/** The client half of the retirement criterion, from socket client identity. */
+export interface ComputerLiveViewClients {
+    readable: boolean;
+    windowDays: number;
+    /** When the record began; the half is only measurable once it covers a whole window. */
+    recordingSince?: string;
+    coversWindow?: boolean;
+    clients: ComputerLiveViewClient[];
+    mobileVersions?: string[];
+    /** Clients that sent no identity: possibly an old mobile build. */
+    unattributed?: number;
+    mobileHalfMet: boolean | null;
+}
+/** `GET /api/machines/computer-adoption` — admin only (OSK-13578, OSK-13616). */
+export interface ComputerAdoption {
+    generatedAt: string;
+    windows: Record<string, {
+        all: ComputerAdoptionCounts;
+        field: ComputerAdoptionCounts;
+    }>;
+    announced: Record<string, number>;
+    /** Absent from a server older than OSK-13616. */
+    liveViewClients?: ComputerLiveViewClients;
+    criterion: {
+        maxLegacyOnlyShare: number;
+        windowDays: number;
+        mobileMoved: string;
+        oldFamilies: string[];
+        daemonHalfMet: boolean | null;
+        mobileHalfMet?: boolean | null;
+        /** Set once the families were retired; absent from a server before OSK-13509. */
+        retired?: {
+            on: string;
+            reason: string;
+        };
+    };
+}
+/**
+ * How many daemons seen recently are still on the old event families rather
+ * than the computer protocol — the number the families' retirement waits on.
+ */
+export declare function getComputerAdoption(): Promise<ComputerAdoption>;
+export declare function computerAdoptionLines(read: ComputerAdoption): string[];

package/dist/lib/computer-adoption.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComputerAdoption = getComputerAdoption;
+exports.computerAdoptionLines = computerAdoptionLines;
+const api_fetch_1 = require("./api-fetch");
+/**
+ * How many daemons seen recently are still on the old event families rather
+ * than the computer protocol — the number the families' retirement waits on.
+ */
+async function getComputerAdoption() {
+    return (0, api_fetch_1.apiFetch)('/api/machines/computer-adoption');
+}
+function percent(share) {
+    return share === null ? 'n/a (no active daemons)' : `${(share * 100).toFixed(1)}%`;
+}
+function countsLines(label, counts) {
+    return [
+        `  ${label}: ${counts.active} active`,
+        `    computer only ${counts.computerOnly} · both ${counts.both} · old families only ${counts.legacyOnly} · neither ${counts.neither}`,
+        `    still on the old families only: ${percent(counts.legacyOnlyShare)}   announcing an old family: ${percent(counts.announcingOldShare)}`,
+    ];
+}
+function mobileHalfLine(read) {
+    const clients = read.liveViewClients;
+    if (!clients)
+        return `  mobile half: ${read.criterion.mobileMoved}`;
+    if (!clients.readable)
+        return '  mobile half: not measurable: the client record could not be read';
+    const versions = clients.mobileVersions ?? [];
+    if (clients.mobileHalfMet === false) {
+        return `  mobile half (no mobile build opened a live view in ${clients.windowDays} days): NOT met — still on it: ${versions.join(', ')}`;
+    }
+    if (clients.mobileHalfMet === null && clients.coversWindow === false) {
+        return `  mobile half: not measurable yet: the record began ${clients.recordingSince ?? 'recently'} and needs ${clients.windowDays} days`;
+    }
+    if (clients.mobileHalfMet === null) {
+        return `  mobile half: not measurable: ${clients.unattributed ?? 0} client build(s) opened a live view without saying what they are`;
+    }
+    return `  mobile half (no mobile build opened a live view in ${clients.windowDays} days): MET`;
+}
+function clientLines(read) {
+    const clients = read.liveViewClients;
+    if (!clients?.readable || clients.clients.length === 0)
+        return [];
+    return [
+        '',
+        `Client builds that opened a browser:liveview:* view in the last ${clients.windowDays}d`,
+        ...clients.clients.map((client) => `  ${client.platform} ${client.os} ${client.version}  last ${client.lastSeenAt}`),
+    ];
+}
+function computerAdoptionLines(read) {
+    const lines = [`Computer protocol adoption (${read.generatedAt})`];
+    for (const [window, scopes] of Object.entries(read.windows)) {
+        lines.push('', `Seen in the last ${window}`);
+        lines.push(...countsLines('all daemons', scopes.all));
+        lines.push(...countsLines('field daemons (no guests)', scopes.field));
+    }
+    const { criterion } = read;
+    let verdict = 'NOT met';
+    if (criterion.daemonHalfMet === null)
+        verdict = 'not measurable: no active daemons';
+    else if (criterion.daemonHalfMet)
+        verdict = 'MET';
+    lines.push('', `Retirement of ${criterion.oldFamilies.join(', ')}`);
+    if (criterion.retired) {
+        // The families are gone: the counts above are who it stranded, not who is still served.
+        lines.push(`  RETIRED ${criterion.retired.on}: ${criterion.retired.reason}`, '  old-families-only daemons above can reach no terminal or browser; each is told to update when it registers');
+    }
+    lines.push(`  daemon half (< ${(criterion.maxLegacyOnlyShare * 100).toFixed(0)}% of daemons active in ${criterion.windowDays} days on the old families only): ${verdict}`, mobileHalfLine(read));
+    lines.push(...clientLines(read));
+    return lines;
+}

package/dist/lib/computer-consent.d.ts

@@ -0,0 +1,55 @@
+import { Command } from '@oclif/core';
+import { type RuntimeBinaryOutput } from './exec-runtime-binary';
+/**
+ * The bridge for `skrr computer` — the machine-local consent for the
+ * computer's new surfaces on a personal machine (design §18, D11;
+ * OSK-13532): the file surface and a person's own browser windows.
+ *
+ * The consent is a decision made ON the machine, so it is implemented by the
+ * local daemon (`skrrd computer allow|deny|status`) writing daemon.json —
+ * never by a REST route, because nothing sent from the cloud may grant it.
+ * Keeping the CLI a thin forwarder preserves that boundary: `skrr` carries
+ * the verb to the same binary `skrrd` runs it on.
+ */
+/** Bound on the `skrrd status --json` probe: it is a read, and must never stall the command. */
+export declare const DAEMON_STATUS_PROBE_TIMEOUT_MS = 8000;
+/** What `skrrd status --json` says about the daemon that would answer. */
+export interface AnsweringDaemon {
+    /** The binary `skrr` forwards to. */
+    binary: string | null;
+    /** The on-disk binary's version (`statusCommandVersion`), when it said. */
+    binaryVersion: string | null;
+    /** The running daemon's version (`liveVersion`/`version`), when it said. */
+    runningVersion: string | null;
+    daemonId: string | null;
+    profile: string | null;
+    /** `update.state` — `source-build`, `update-available`, `restart-pending`, … */
+    updateState: string | null;
+    /** `update.commands`: the install-method-correct way to update THIS daemon. */
+    updateCommands: string[];
+    restartPending: boolean;
+}
+export interface ComputerConsentDeps {
+    supportsSubcommand: (subcommand: string) => Promise<boolean | null>;
+    exec: (args: string[]) => Promise<number>;
+    capture: (args: string[], opts?: {
+        timeoutMs?: number;
+    }) => Promise<RuntimeBinaryOutput>;
+    findBinary: () => string | null;
+}
+/**
+ * Read `skrrd status --json` for the facts a person needs to know WHICH daemon
+ * answered and how it updates. Null when the status cannot be read — the
+ * caller then says what it can without inventing the rest.
+ */
+export declare function readAnsweringDaemon(passthrough?: readonly string[], deps?: ComputerConsentDeps): Promise<AnsweringDaemon | null>;
+/** "skrrd 0.8.103 at /path (daemon_…, running 0.8.90)" — whatever of that is known. */
+export declare function describeAnsweringDaemon(daemon: AnsweringDaemon | null, binary: string | null): string;
+/**
+ * What to tell a person whose local daemon has no `computer` verb: which
+ * daemon answered, and the update path for THAT install (OSK-13822). A source
+ * build updates by rebuilding its checkout — `skrrd status --json` already
+ * carries that recipe under `update.commands` — not by reinstalling.
+ */
+export declare function computerUnsupportedMessage(daemon: AnsweringDaemon | null, binary: string | null): string;
+export declare function forwardComputerConsent(command: Command, passthrough: readonly string[], deps?: ComputerConsentDeps): Promise<void>;

package/dist/lib/computer-consent.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DAEMON_STATUS_PROBE_TIMEOUT_MS = void 0;
+exports.readAnsweringDaemon = readAnsweringDaemon;
+exports.describeAnsweringDaemon = describeAnsweringDaemon;
+exports.computerUnsupportedMessage = computerUnsupportedMessage;
+exports.forwardComputerConsent = forwardComputerConsent;
+const exec_runtime_binary_1 = require("./exec-runtime-binary");
+/**
+ * The bridge for `skrr computer` — the machine-local consent for the
+ * computer's new surfaces on a personal machine (design §18, D11;
+ * OSK-13532): the file surface and a person's own browser windows.
+ *
+ * The consent is a decision made ON the machine, so it is implemented by the
+ * local daemon (`skrrd computer allow|deny|status`) writing daemon.json —
+ * never by a REST route, because nothing sent from the cloud may grant it.
+ * Keeping the CLI a thin forwarder preserves that boundary: `skrr` carries
+ * the verb to the same binary `skrrd` runs it on.
+ */
+/** Bound on the `skrrd status --json` probe: it is a read, and must never stall the command. */
+exports.DAEMON_STATUS_PROBE_TIMEOUT_MS = 8_000;
+const defaultDeps = {
+    supportsSubcommand: exec_runtime_binary_1.runtimeBinarySupportsSubcommand,
+    exec: (args) => (0, exec_runtime_binary_1.execRuntimeBinary)(args),
+    capture: (args, opts) => (0, exec_runtime_binary_1.execRuntimeBinaryCapture)(args, opts),
+    findBinary: exec_runtime_binary_1.findRuntimeBinary,
+};
+function text(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+/**
+ * Read `skrrd status --json` for the facts a person needs to know WHICH daemon
+ * answered and how it updates. Null when the status cannot be read — the
+ * caller then says what it can without inventing the rest.
+ */
+async function readAnsweringDaemon(passthrough = [], deps = defaultDeps) {
+    let output;
+    try {
+        output = await deps.capture([...profileArgs(passthrough), 'status', '--json'], {
+            timeoutMs: exports.DAEMON_STATUS_PROBE_TIMEOUT_MS,
+        });
+    }
+    catch {
+        return null;
+    }
+    let status;
+    try {
+        status = JSON.parse(output.stdout);
+    }
+    catch {
+        return null;
+    }
+    if (!status || typeof status !== 'object')
+        return null;
+    const update = status.update && typeof status.update === 'object'
+        ? status.update
+        : {};
+    return {
+        binary: deps.findBinary(),
+        binaryVersion: text(status.statusCommandVersion),
+        runningVersion: text(status.liveVersion) ?? text(status.version),
+        daemonId: text(status.daemonId),
+        profile: text(status.profile),
+        updateState: text(update.state),
+        updateCommands: Array.isArray(update.commands)
+            ? update.commands.filter((c) => typeof c === 'string' && c.trim() !== '')
+            : [],
+        restartPending: update.restartPending === true,
+    };
+}
+/** `--profile <name>` from the pass-through, so the status probe asks the same daemon. */
+function profileArgs(passthrough) {
+    for (let i = 0; i < passthrough.length; i += 1) {
+        const arg = passthrough[i];
+        if (arg === '--profile' && passthrough[i + 1])
+            return ['--profile', passthrough[i + 1]];
+        if (arg.startsWith('--profile='))
+            return ['--profile', arg.slice('--profile='.length)];
+    }
+    return [];
+}
+/** "skrrd 0.8.103 at /path (daemon_…, running 0.8.90)" — whatever of that is known. */
+function describeAnsweringDaemon(daemon, binary) {
+    const where = daemon?.binary ?? binary;
+    const parts = [];
+    parts.push(`${where ?? 'skrrd'}${daemon?.binaryVersion ? ` (v${daemon.binaryVersion} on disk)` : ''}`);
+    if (daemon?.runningVersion && daemon.runningVersion !== daemon.binaryVersion) {
+        parts.push(`running daemon v${daemon.runningVersion}`);
+    }
+    else if (daemon?.runningVersion && !daemon.binaryVersion) {
+        parts.push(`v${daemon.runningVersion}`);
+    }
+    if (daemon?.daemonId)
+        parts.push(daemon.daemonId);
+    return parts.join(', ');
+}
+/**
+ * What to tell a person whose local daemon has no `computer` verb: which
+ * daemon answered, and the update path for THAT install (OSK-13822). A source
+ * build updates by rebuilding its checkout — `skrrd status --json` already
+ * carries that recipe under `update.commands` — not by reinstalling.
+ */
+function computerUnsupportedMessage(daemon, binary) {
+    const lines = [
+        `The local daemon does not support \`skrr computer\` yet: ${describeAnsweringDaemon(daemon, binary)}.`,
+    ];
+    if (daemon?.updateState === 'source-build') {
+        const recipe = daemon.updateCommands.length
+            ? daemon.updateCommands
+            : ['cd <daemon-dir> && git pull && npm run build'];
+        lines.push('It runs from a source checkout, which updates by rebuilding:');
+        for (const command of recipe)
+            lines.push(`  ${command}`);
+        lines.push('Then restart it:', '  skrr daemon restart');
+    }
+    else if (daemon?.restartPending) {
+        lines.push('A newer daemon is already on disk; the running one predates it. Restart it:', '  skrr daemon restart');
+    }
+    else if (daemon && daemon.updateCommands.length > 0) {
+        lines.push('Update it:');
+        for (const command of daemon.updateCommands)
+            lines.push(`  ${command}`);
+        lines.push('Then restart it:', '  skrr daemon restart');
+    }
+    else {
+        lines.push('Update it (`skrr daemon update`, or reinstall it), restart it (`skrr daemon restart`), then retry.');
+    }
+    return lines.join('\n');
+}
+async function forwardComputerConsent(command, passthrough, deps = defaultDeps) {
+    try {
+        // Older daemons treated unknown subcommands as a daemon startup in some
+        // releases. Probe the command list before forwarding so a consent verb
+        // cannot turn into a surprising service mutation.
+        if ((await deps.supportsSubcommand('computer')) === false) {
+            const daemon = await readAnsweringDaemon(passthrough, deps);
+            command.error(computerUnsupportedMessage(daemon, deps.findBinary()), { exit: 2 });
+        }
+        if (passthrough.includes('status')) {
+            // Which daemon answered, before its answer — on stderr, so `--json`
+            // output stays exactly what the daemon printed.
+            const daemon = await readAnsweringDaemon(passthrough, deps);
+            command.logToStderr(`Answered by: ${describeAnsweringDaemon(daemon, deps.findBinary())}`);
+        }
+        command.exit(await deps.exec(['computer', ...passthrough]));
+    }
+    catch (error) {
+        if (error.message === 'runtime-binary-not-installed') {
+            command.log((0, exec_runtime_binary_1.notInstalledMessage)());
+            command.exit(127);
+        }
+        throw error;
+    }
+}