@skrr-ai/cli 0.1.12 → 0.1.14

package/dist/lib/{exec-oversky.js → exec-runtime-binary.js}

@@ -5,12 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RUNTIME_BINARY_NAMES = void 0;
 exports.forwardedFlagsNote = forwardedFlagsNote;
-exports.findOverskyBinary = findOverskyBinary;
+exports.findRuntimeBinary = findRuntimeBinary;
+exports.isCurrentRuntimeBinary = isCurrentRuntimeBinary;
+exports.normalizeRuntimeGlobalArgs = normalizeRuntimeGlobalArgs;
 exports.notInstalledMessage = notInstalledMessage;
-exports.execOversky = execOversky;
-exports.overskySupportsSubcommand = overskySupportsSubcommand;
+exports.execRuntimeBinary = execRuntimeBinary;
+exports.runtimeBinarySupportsSubcommand = runtimeBinarySupportsSubcommand;
 /**
- * exec-oversky.ts — locate and forward to the local runtime binary.
+ * exec-runtime-binary.ts — locate and forward to the local runtime binary.
  *
  * The `gh → git` pattern: `skrr daemon ...` is a thin proxy. `skrr` is a REST
  * client; `skrrd` is the long-running runtime. Keeping them as separate
@@ -60,9 +62,13 @@ exports.RUNTIME_BINARY_NAMES = ['skrrd', 'oversky'];
  * `description` alone.
  */
 function forwardedFlagsNote(verb, opts = {}) {
-    const base = `Flags are forwarded to \`skrrd ${verb}\` unchanged, so they are not listed here —` +
-        ` run \`skrrd ${verb} --help\` for this verb's own flags, or \`skrrd --help\` for` +
-        ' global ones such as `--profile`.';
+    const base = opts.bootstrapsRuntime
+        ? `If no local runtime exists, this command first fetches the signed release. After it is ` +
+            `installed, flags are forwarded to \`skrrd ${verb}\` unchanged; run \`skrrd ${verb} --help\` ` +
+            `for this verb's own flags, or \`skrrd --help\` for global ones such as \`--profile\`.`
+        : `Flags are forwarded to \`skrrd ${verb}\` unchanged, so they are not listed here —` +
+            ` run \`skrrd ${verb} --help\` for this verb's own flags, or \`skrrd --help\` for` +
+            ' global ones such as `--profile`.';
     // `install` and `login` are not pure pass-throughs: they fill in the server
     // and profile from the CLI's own session when the caller named neither, so a
     // daemon cannot silently end up on a different deployment than the CLI that
@@ -72,41 +78,91 @@ function forwardedFlagsNote(verb, opts = {}) {
         ? `${base} \`--server\` and \`--profile\` are filled in from your CLI session unless you pass them.`
         : base;
 }
-/** Extra well-known install locations to check when PATH lookup misses. */
-const FALLBACK_PATHS = exports.RUNTIME_BINARY_NAMES.flatMap((name) => [
-    `/opt/homebrew/bin/${name}`,
-    `/usr/local/bin/${name}`,
-    // Linux script-installer default; the daemon's install script drops here.
-    `/usr/local/bin/${name}-daemon`,
-    // EC2 / pm2 layout used in daemon/CLAUDE.md examples.
-    `${process.env.HOME ?? ''}/.skrr/bin/${name}`,
-]);
-/** Resolve the absolute path of `oversky` if it exists, else return null. */
-function findOverskyBinary() {
+/** Extra well-known install locations for one runtime name, checked after PATH. */
+function fallbackPathsForRuntime(name) {
+    return [
+        `/opt/homebrew/bin/${name}`,
+        `/usr/local/bin/${name}`,
+        // Linux script-installer default; the daemon's install script drops here.
+        `/usr/local/bin/${name}-daemon`,
+        // EC2 / pm2 layout used in daemon/CLAUDE.md examples.
+        `${process.env.HOME ?? ''}/.skrr/bin/${name}`,
+    ];
+}
+/** Resolve the local runtime binary — `skrrd`, or the legacy `oversky` still on older PATHs. */
+function findRuntimeBinary() {
     // PATH lookup — Node 20 doesn't ship `which()` but we can mimic it.
     // On Windows, npm globals install a `.cmd` wrapper (not `.exe`) so we
     // must check both; installers that ship a native build still win
     // because `.exe` is checked first.
     const PATH = process.env.PATH ?? '';
     const sep = process.platform === 'win32' ? ';' : ':';
-    const exeNames = process.platform === 'win32'
-        ? exports.RUNTIME_BINARY_NAMES.flatMap((n) => [`${n}.exe`, `${n}.cmd`])
-        : [...exports.RUNTIME_BINARY_NAMES];
-    for (const dir of PATH.split(sep)) {
-        if (!dir)
-            continue;
-        for (const exeName of exeNames) {
-            const candidate = node_path_1.default.join(dir, exeName);
-            if (isExecutable(candidate))
+    const executableNamesFor = (name) => process.platform === 'win32' ? [`${name}.exe`, `${name}.cmd`] : [name];
+    // Check EVERY location for the current name before falling back to the
+    // legacy name. The former loop was directory-first, so an `oversky` binary
+    // in an early PATH entry won over a current `skrrd` in a later managed
+    // location. That stranded onboarding on the old binary precisely when it
+    // needed the current runtime to bootstrap its service.
+    const dirs = PATH.split(sep).filter(Boolean);
+    for (const runtimeName of exports.RUNTIME_BINARY_NAMES) {
+        for (const exeName of executableNamesFor(runtimeName)) {
+            for (const dir of dirs) {
+                const candidate = node_path_1.default.join(dir, exeName);
+                if (isExecutable(candidate))
+                    return candidate;
+            }
+        }
+        for (const candidate of fallbackPathsForRuntime(runtimeName)) {
+            if (candidate && isExecutable(candidate))
                 return candidate;
         }
     }
-    for (const candidate of FALLBACK_PATHS) {
-        if (candidate && isExecutable(candidate))
-            return candidate;
-    }
     return null;
 }
+/** Whether a resolved path names the current runtime rather than legacy oversky. */
+function isCurrentRuntimeBinary(binary) {
+    if (!binary)
+        return false;
+    const basename = node_path_1.default.basename(binary).toLowerCase();
+    return process.platform === 'win32'
+        ? basename === 'skrrd.exe' || basename === 'skrrd.cmd'
+        : basename === 'skrrd';
+}
+/**
+ * Commander reads runtime global options before the subcommand. The CLI
+ * wrappers naturally receive pass-through flags after a verb (`install
+ * --profile work`), which otherwise silently resolves the runtime profile as
+ * default. Move a well-formed profile flag ahead of the verb without changing
+ * the order of any command-specific flags or `--` payload.
+ */
+function normalizeRuntimeGlobalArgs(args) {
+    const rest = [];
+    let profile = null;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--') {
+            rest.push(...args.slice(index));
+            break;
+        }
+        if (arg === '--profile') {
+            const value = args[index + 1];
+            if (value && !value.startsWith('-')) {
+                profile = value;
+                index += 1;
+                continue;
+            }
+        }
+        if (arg.startsWith('--profile=')) {
+            const value = arg.slice('--profile='.length);
+            if (value) {
+                profile = value;
+                continue;
+            }
+        }
+        rest.push(arg);
+    }
+    return profile ? ['--profile', profile, ...rest] : rest;
+}
 function isExecutable(p) {
     try {
         (0, node_fs_1.accessSync)(p, node_fs_1.constants.X_OK);
@@ -155,11 +211,11 @@ function notInstalledMessage() {
  * preserving "exit code = the daemon's exit code" semantics that scripts
  * may depend on.
  */
-function execOversky(args) {
+function execRuntimeBinary(args) {
     return new Promise((resolve, reject) => {
-        const bin = findOverskyBinary();
+        const bin = findRuntimeBinary();
         if (!bin) {
-            reject(new Error('oversky-not-installed'));
+            reject(new Error('runtime-binary-not-installed'));
             return;
         }
         // On Windows, `.cmd` / `.bat` wrappers cannot be executed directly by
@@ -169,7 +225,7 @@ function execOversky(args) {
         // by package.json engines `>=20.0.0` — pin at install time) quotes
         // args when shell:true on Windows per CVE-2024-27980's fix.
         const isWinShim = process.platform === 'win32' && /\.(cmd|bat)$/i.test(bin);
-        const child = (0, node_child_process_1.spawn)(bin, args, {
+        const child = (0, node_child_process_1.spawn)(bin, normalizeRuntimeGlobalArgs(args), {
             stdio: 'inherit',
             ...(isWinShim ? { shell: true } : {}),
         });
@@ -195,8 +251,8 @@ function execOversky(args) {
  * This invokes only `oversky --help`: it never starts, stops, configures, or
  * otherwise mutates the local daemon.
  */
-function overskySupportsSubcommand(subcommand) {
-    const bin = findOverskyBinary();
+function runtimeBinarySupportsSubcommand(subcommand) {
+    const bin = findRuntimeBinary();
     if (!bin)
         return Promise.resolve(null);
     return new Promise((resolve) => {

package/dist/lib/node-adapter.js

@@ -317,9 +317,15 @@ function createNodeAdapter(opts = {}) {
             // can contain internal stack traces we don't want to echo to
             // terminals by default.
             const text = await res.text().catch(() => '');
+            // `method` is attached because the 403 branch of `handleApiError` needs
+            // to know whether the failing request even HAD a body before it can
+            // advise the user to "try again with less of the request body"
+            // (OSK-6765): `agents show` is a GET and had no body, so the advice
+            // could not be followed.
             const err = new Error(`HTTP ${res.status} ${res.statusText} — ${method} ${url}`);
             err.status = res.status;
             err.body = text;
+            err.method = method;
             throw err;
         }
         if (options?.responseType === 'arraybuffer') {

package/dist/lib/sky-code.d.ts

@@ -1,7 +1,7 @@
 /**
  * WL-2.2 — locate and forward to the local `sky-code` engine.
  *
- * The same `gh → git` shape `exec-oversky.ts` uses, for the same reason: the
+ * The same `gh → git` shape `exec-runtime-binary.ts` uses, for the same reason: the
  * Sky CLI is a REST client, the engine is a separately-built, separately-
  * released binary with its own lifetime and failure model. Unifying them at
  * the command surface (`skrr code`) gives users one thing to type without

package/dist/lib/sky-code.js

@@ -2,7 +2,7 @@
 /**
  * WL-2.2 — locate and forward to the local `sky-code` engine.
  *
- * The same `gh → git` shape `exec-oversky.ts` uses, for the same reason: the
+ * The same `gh → git` shape `exec-runtime-binary.ts` uses, for the same reason: the
  * Sky CLI is a REST client, the engine is a separately-built, separately-
  * released binary with its own lifetime and failure model. Unifying them at
  * the command surface (`skrr code`) gives users one thing to type without

package/dist/lib/usage-discovery.js

@@ -108,7 +108,7 @@ function renderUsageReference(reference, bin = 'skrr') {
     ];
     for (const command of reference.data) {
         const flags = command.keyFlags.length > 0 ? ` Flags: ${command.keyFlags.join(', ')}.` : '';
-        lines.push(`sky ${command.command} — ${command.description}.${flags} Example: ${command.example}`);
+        lines.push(`${bin} ${command.command} — ${command.description}.${flags} Example: ${command.example}`);
     }
     if (reference.nextPage)
         lines.push(`Next: ${bin} usage ${reference.domain} --page ${reference.nextPage}`);

package/dist/lib/web-url.d.ts

@@ -69,6 +69,10 @@ export type WebUrlRef = {
 } | {
     kind: 'groupChat';
     groupChatId: string;
+} | {
+    kind: 'wikiPage';
+    spaceId: string;
+    pageId: string;
 };
 /**
  * Site-relative canonical path for an entity, or `null` when the required id is
@@ -146,6 +150,18 @@ export declare function projectUrlFrom(baseURL: string, project: EntityRecord):
 export declare function withProjectUrl<T extends EntityRecord>(baseURL: string, project: T): T & {
     url: string | null;
 };
+/**
+ * Build a wiki-page URL from a raw server page record.
+ *
+ * The server returns `pageId`, never `id`; the fallback reads exist so a
+ * caller that has already normalized the record still gets a link back
+ * instead of null.
+ */
+export declare function wikiPageUrlFrom(baseURL: string, page: EntityRecord): string | null;
+/** Return a shallow copy of a wiki-page record with a `url` field attached. */
+export declare function withWikiPageUrl<T extends EntityRecord>(baseURL: string, page: T): T & {
+    url: string | null;
+};
 /** Return a shallow copy of a commitment record with a `url` field attached. */
 export declare function withCommitmentUrl<T extends EntityRecord>(baseURL: string, commitment: T): T & {
     url: string | null;

package/dist/lib/web-url.js

@@ -35,6 +35,8 @@ exports.withSpaceUrl = withSpaceUrl;
 exports.withGoalUrl = withGoalUrl;
 exports.projectUrlFrom = projectUrlFrom;
 exports.withProjectUrl = withProjectUrl;
+exports.wikiPageUrlFrom = wikiPageUrlFrom;
+exports.withWikiPageUrl = withWikiPageUrl;
 exports.withCommitmentUrl = withCommitmentUrl;
 exports.withNorthstarUrl = withNorthstarUrl;
 exports.withAgentUrl = withAgentUrl;
@@ -103,6 +105,11 @@ function webPath(ref) {
             const projectId = encodeId(ref.projectId);
             return projectId ? `/spaces/${spaceId}/projects/${projectId}` : `/spaces/${spaceId}/projects`;
         }
+        case 'wikiPage': {
+            const spaceId = encodeId(ref.spaceId);
+            const pageId = encodeId(ref.pageId);
+            return spaceId && pageId ? `/spaces/${spaceId}/wiki?page=${pageId}` : null;
+        }
         case 'workflow': {
             const spaceId = encodeId(ref.spaceId);
             if (!spaceId)
@@ -282,6 +289,24 @@ function projectUrlFrom(baseURL, project) {
 function withProjectUrl(baseURL, project) {
     return { ...project, url: projectUrlFrom(baseURL, project) };
 }
+/**
+ * Build a wiki-page URL from a raw server page record.
+ *
+ * The server returns `pageId`, never `id`; the fallback reads exist so a
+ * caller that has already normalized the record still gets a link back
+ * instead of null.
+ */
+function wikiPageUrlFrom(baseURL, page) {
+    const pageId = idOf(page, 'pageId', 'id', '_id');
+    const spaceId = idOf(page, 'spaceId');
+    if (!pageId || !spaceId)
+        return null;
+    return webUrl(baseURL, { kind: 'wikiPage', spaceId, pageId });
+}
+/** Return a shallow copy of a wiki-page record with a `url` field attached. */
+function withWikiPageUrl(baseURL, page) {
+    return { ...page, url: wikiPageUrlFrom(baseURL, page) };
+}
 /** Return a shallow copy of a commitment record with a `url` field attached. */
 function withCommitmentUrl(baseURL, commitment) {
     return { ...commitment, url: commitmentUrlFrom(baseURL, commitment) };