@neta-art/cohub-cli 6.8.0 → 6.8.2

package/dist/bootstrap.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { envProxyExecArgv, shouldRelaunchWithEnvProxy } from "./env-proxy.js";
+import { relaunchCli } from "./launcher.js";
 import { ensureCliSelfUpdated, SELF_UPDATE_WORKER_ENV, startCliSelfUpdate } from "./self-update.js";
 const argv = process.argv.slice(2);
 const isVersionRequest = argv.some((arg) => arg === "-v" || arg === "--version");
@@ -11,6 +13,14 @@ if (process.env[SELF_UPDATE_WORKER_ENV] === "1") {
     }
     process.exit(0);
 }
+if (!isVersionRequest && shouldRelaunchWithEnvProxy()) {
+    const entrypoint = process.argv[1];
+    if (entrypoint) {
+        process.exit(await relaunchCli(entrypoint, argv, {
+            execArgv: [...envProxyExecArgv, ...process.execArgv],
+        }));
+    }
+}
 if (!isVersionRequest) {
     const entrypoint = process.argv[1];
     if (entrypoint)

package/dist/commands/apps.js

@@ -1,5 +1,4 @@
 import { randomUUID } from "node:crypto";
-import { createReadStream } from "node:fs";
 import { basename } from "node:path";
 import { getCohubContext, HttpError } from "@neta-art/cohub";
 import { createClient, createClientWithAccessToken } from "../client.js";
@@ -8,6 +7,7 @@ import { resolveSpace } from "../space.js";
 import { downloadApp } from "../app-download.js";
 import { getAppByRef, parseAppRef } from "../app-ref.js";
 import { checkAppTarget } from "../app-target.js";
+import { putBytes, putLocalFile } from "../http-put.js";
 import { registerAppCommerce } from "./app-commerce.js";
 import { collectPublicUpload } from "./public.js";
 const APP_STATUSES = ["published", "disabled"];
@@ -90,14 +90,13 @@ async function uploadLocalAppSource(client, spaceId, source) {
                 sessionId: uploadId,
                 file: { size: file.size, mimeType: file.mimeType, filename: basename(file.publicPath) },
             });
-            const response = await fetch(plan.asset.uploadUrl, {
-                method: "PUT",
+            await putLocalFile({
+                url: plan.asset.uploadUrl,
+                filePath: file.localPath,
+                size: file.size,
                 headers: plan.asset.uploadHeaders,
-                body: createReadStream(file.localPath),
-                duplex: "half",
+                label: file.publicPath,
             });
-            if (!response.ok)
-                throw new Error(`Failed to upload ${file.publicPath}: HTTP ${response.status}`);
             const path = directoryPrefix && file.publicPath.startsWith(`${directoryPrefix}/`)
                 ? file.publicPath.slice(directoryPrefix.length + 1)
                 : basename(file.publicPath);
@@ -114,13 +113,13 @@ async function uploadLocalAppSource(client, spaceId, source) {
         sessionId: uploadId,
         file: { size: manifestBlob.size, mimeType: "application/json", filename: "manifest.json" },
     });
-    const manifestResponse = await fetch(manifestPlan.asset.uploadUrl, {
-        method: "PUT",
-        headers: manifestPlan.asset.uploadHeaders,
+    await putBytes({
+        url: manifestPlan.asset.uploadUrl,
         body: manifestBlob,
+        size: manifestBlob.size,
+        headers: manifestPlan.asset.uploadHeaders,
+        label: "app source manifest",
     });
-    if (!manifestResponse.ok)
-        throw new Error(`Failed to upload app source manifest: HTTP ${manifestResponse.status}`);
     const manifestAsset = manifestPlan.asset;
     return { sourceRef: manifestAsset.objectKey, targetRef: source.targetType === "file" ? files[0]?.path ?? "" : "." };
 }

package/dist/commands/public.js

@@ -1,8 +1,8 @@
 import { randomUUID } from "node:crypto";
-import { createReadStream } from "node:fs";
 import { lstat, readdir } from "node:fs/promises";
 import { basename, extname, relative, resolve } from "node:path";
 import { createClient } from "../client.js";
+import { HttpPutError, putLocalFile } from "../http-put.js";
 import { error, handleHttp, json as outJson, jsonRequested } from "../output.js";
 import { resolveSpace } from "../space.js";
 const UPLOAD_CONCURRENCY = 4;
@@ -149,19 +149,22 @@ async function mapSettledWithConcurrency(items, concurrency, mapper) {
     return errors;
 }
 async function putPublicFile(file, plan, fetchImpl) {
-    const response = await fetchImpl(plan.uploadUrl, {
-        method: "PUT",
-        headers: plan.headers,
-        body: createReadStream(file.localPath),
-        duplex: "half",
-    });
-    if (response.ok)
-        return;
-    const detail = await response.text().catch(() => "");
-    if (response.status === 409 || response.status === 412) {
-        throw new Error(`${file.publicPath} already exists. Use --overwrite.`);
+    try {
+        await putLocalFile({
+            url: plan.uploadUrl,
+            filePath: file.localPath,
+            size: file.size,
+            headers: plan.headers,
+            label: file.publicPath,
+            fetch: fetchImpl,
+        });
+    }
+    catch (error) {
+        if (error instanceof HttpPutError && (error.status === 409 || error.status === 412)) {
+            throw new Error(`${file.publicPath} already exists. Use --overwrite.`);
+        }
+        throw error;
     }
-    throw new Error(`Failed to upload ${file.publicPath}: HTTP ${response.status}${detail ? ` — ${detail}` : ""}`);
 }
 function uploadFailure(errors) {
     if (errors.length === 1)

package/dist/commands/run.d.ts

@@ -1 +1,2 @@
+export declare function printRunHelp(): void;
 export declare function maybeHandleRunCommand(argv: string[]): Promise<boolean>;

package/dist/commands/run.js

@@ -107,7 +107,7 @@ async function parseRunCliOptions(argv) {
     const spaceId = explicitSpaceId || (await resolveDefaultSpace().catch(handleHttp)) || missingSpaceError();
     return { spaceId, json, async, command };
 }
-function printRunHelp() {
+export function printRunHelp() {
     process.stdout.write(`
 Usage:
   cohub [-s <spaceId>] run [options] -- <shell command>

package/dist/commands/spaces.js

@@ -1,10 +1,10 @@
 import { randomUUID } from "node:crypto";
-import { createReadStream } from "node:fs";
 import { readdir, stat } from "node:fs/promises";
 import { basename, dirname, relative, resolve, sep } from "node:path";
 import { resolveCohubEnvironment } from "@neta-art/cohub";
 import { uploadAvatarAsset, uploadChatImageAsset } from "../avatar.js";
 import { createClient } from "../client.js";
+import { putLocalFile } from "../http-put.js";
 import { table, json as outJson, jsonRequested, ok, error, handleHttp, formatEpochMs } from "../output.js";
 import { resolveSpace } from "../space.js";
 import { registerSpaceCommerce } from "./space-commerce.js";
@@ -156,16 +156,13 @@ export async function collectUploadFiles(paths) {
     return files;
 }
 async function putUploadEntry(entry, uploadUrl, headers) {
-    const response = await fetch(uploadUrl, {
-        method: "PUT",
+    await putLocalFile({
+        url: uploadUrl,
+        filePath: entry.localPath,
+        size: entry.size,
         headers,
-        body: createReadStream(entry.localPath),
-        duplex: "half",
+        label: entry.relativePath,
     });
-    if (!response.ok) {
-        const detail = await response.text().catch(() => "");
-        throw new Error(`Failed to upload ${entry.relativePath}: HTTP ${response.status}${detail ? ` — ${detail}` : ""}`);
-    }
 }
 async function uploadFiles(command, paths, opts) {
     const spaceId = await resolveSpace(command);

package/dist/env-proxy.d.ts

@@ -0,0 +1,5 @@
+export declare function proxyEnvPresent(env?: NodeJS.ProcessEnv): boolean;
+export declare function envProxyAlreadyEnabled(execArgv?: readonly string[], env?: NodeJS.ProcessEnv): boolean;
+export declare function supportsUseEnvProxy(version?: string): boolean;
+export declare function shouldRelaunchWithEnvProxy(execArgv?: readonly string[], env?: NodeJS.ProcessEnv, nodeVersion?: string): boolean;
+export declare const envProxyExecArgv: readonly ["--use-env-proxy"];

package/dist/env-proxy.js

@@ -0,0 +1,20 @@
+const PROXY_ENV_KEYS = ["http_proxy", "https_proxy", "HTTP_PROXY", "HTTPS_PROXY", "all_proxy", "ALL_PROXY"];
+const USE_ENV_PROXY_FLAG = "--use-env-proxy";
+export function proxyEnvPresent(env = process.env) {
+    return PROXY_ENV_KEYS.some((key) => Boolean(env[key]?.trim()));
+}
+export function envProxyAlreadyEnabled(execArgv = process.execArgv, env = process.env) {
+    if (execArgv.includes(USE_ENV_PROXY_FLAG) || env.NODE_USE_ENV_PROXY === "1")
+        return true;
+    return (env.NODE_OPTIONS ?? "").split(/\s+/).includes(USE_ENV_PROXY_FLAG);
+}
+export function supportsUseEnvProxy(version = process.versions.node) {
+    const [major = 0, minor = 0] = version.split(".").map((part) => Number.parseInt(part, 10));
+    if (!Number.isFinite(major) || !Number.isFinite(minor))
+        return false;
+    return major >= 24 || (major === 22 && minor >= 21);
+}
+export function shouldRelaunchWithEnvProxy(execArgv = process.execArgv, env = process.env, nodeVersion = process.versions.node) {
+    return supportsUseEnvProxy(nodeVersion) && proxyEnvPresent(env) && !envProxyAlreadyEnabled(execArgv, env);
+}
+export const envProxyExecArgv = [USE_ENV_PROXY_FLAG];

package/dist/help-path.d.ts

@@ -0,0 +1,18 @@
+import type { Command } from "commander";
+export type HelpResolution = {
+    kind: "passthrough";
+} | {
+    kind: "help";
+    command: Command;
+} | {
+    kind: "run-help";
+} | {
+    kind: "unknown";
+    token: string;
+    tryCommand?: string;
+    suggestion?: string;
+};
+export declare function resolveHelpPath(program: Command, argv: string[]): HelpResolution;
+export declare function formatUnknownCommandError(result: Extract<HelpResolution, {
+    kind: "unknown";
+}>): string;

package/dist/help-path.js

@@ -0,0 +1,223 @@
+function isHelpFlag(token) {
+    return token === "-h" || token === "--help";
+}
+function findChild(command, name) {
+    return command.commands.find((child) => {
+        if (child.name() === "help")
+            return false;
+        return child.name() === name || child.aliases().includes(name);
+    });
+}
+function hasSubcommands(command) {
+    return command.commands.some((child) => child.name() !== "help");
+}
+function knownOptions(command) {
+    const options = [];
+    let current = command;
+    while (current) {
+        options.push(...current.options);
+        current = current.parent;
+    }
+    return options;
+}
+function matchOption(command, token) {
+    if (!token.startsWith("-") || token === "-")
+        return undefined;
+    const eq = token.indexOf("=");
+    const inline = eq >= 0;
+    const flag = inline ? token.slice(0, eq) : token;
+    for (const option of knownOptions(command)) {
+        if (option.short === flag || option.long === flag)
+            return { option, inline };
+    }
+    return undefined;
+}
+function skipOption(command, argv, index) {
+    const token = argv[index] ?? "";
+    const matched = matchOption(command, token);
+    const next = index + 1;
+    if (matched?.inline)
+        return next;
+    const value = argv[next];
+    if (!value)
+        return next;
+    if (matched?.option.required)
+        return next + 1;
+    if (matched?.option.optional && !value.startsWith("-"))
+        return next + 1;
+    return next;
+}
+function remainderRequestsHelp(command, argv) {
+    let index = 0;
+    while (index < argv.length) {
+        const token = argv[index] ?? "";
+        if (token === "--")
+            break;
+        if (isHelpFlag(token))
+            return true;
+        if (token.startsWith("-")) {
+            index = skipOption(command, argv, index);
+            continue;
+        }
+        index += 1;
+    }
+    return false;
+}
+/** Match `run.ts`: Cohub flags first, then the rest is the shell command. */
+function runRemainderRequestsHelp(argv) {
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index] ?? "";
+        if (token === "--")
+            return false;
+        if (isHelpFlag(token))
+            return true;
+        if (token === "--async" || token === "--json")
+            continue;
+        if (token === "-c" || token === "--command") {
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--command="))
+            continue;
+        return false;
+    }
+    return false;
+}
+function walkCommandPath(program, argv) {
+    let command = program;
+    const path = [];
+    let helpRequested = false;
+    let index = 0;
+    while (index < argv.length) {
+        const token = argv[index] ?? "";
+        if (token === "--")
+            break;
+        if (isHelpFlag(token)) {
+            helpRequested = true;
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("-")) {
+            index = skipOption(command, argv, index);
+            continue;
+        }
+        if (token === "help" && hasSubcommands(command)) {
+            helpRequested = true;
+            index += 1;
+            continue;
+        }
+        const child = findChild(command, token);
+        if (child) {
+            command = child;
+            path.push(child.name());
+            index += 1;
+            continue;
+        }
+        if (hasSubcommands(command)) {
+            const remainder = argv.slice(index + 1);
+            const helpAfter = token === "run" && path.length === 0
+                ? runRemainderRequestsHelp(remainder)
+                : remainderRequestsHelp(command, remainder);
+            return {
+                command,
+                path,
+                helpRequested: helpRequested || helpAfter,
+                unknown: token,
+            };
+        }
+        index += 1;
+    }
+    return { command, path, helpRequested, unknown: null };
+}
+function stripRootCommand(program, argv, name) {
+    let index = 0;
+    while (index < argv.length) {
+        const token = argv[index] ?? "";
+        if (token === "--")
+            return undefined;
+        if (isHelpFlag(token) || token === "help") {
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("-")) {
+            index = skipOption(program, argv, index);
+            continue;
+        }
+        if (token !== name)
+            return undefined;
+        return [...argv.slice(0, index), ...argv.slice(index + 1)];
+    }
+    return undefined;
+}
+function editDistance(a, b) {
+    if (a === b)
+        return 0;
+    if (Math.abs(a.length - b.length) > 3)
+        return Math.max(a.length, b.length);
+    const rows = a.length + 1;
+    const cols = b.length + 1;
+    const previous = Array.from({ length: cols }, (_, index) => index);
+    const current = new Array(cols);
+    for (let i = 1; i < rows; i += 1) {
+        current[0] = i;
+        for (let j = 1; j < cols; j += 1) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            current[j] = Math.min((previous[j] ?? 0) + 1, (current[j - 1] ?? 0) + 1, (previous[j - 1] ?? 0) + cost);
+        }
+        for (let j = 0; j < cols; j += 1)
+            previous[j] = current[j] ?? 0;
+    }
+    return previous[b.length] ?? Math.max(a.length, b.length);
+}
+function suggestCommand(command, token) {
+    const names = [...new Set(command.commands.flatMap((child) => {
+            if (child.name() === "help" || child.name().length <= 1)
+                return [];
+            return [child.name(), ...child.aliases().filter((alias) => alias.length > 1)];
+        }))];
+    let best;
+    let bestDistance = 3;
+    for (const name of names) {
+        const distance = editDistance(token, name);
+        const length = Math.max(token.length, name.length);
+        if (distance >= bestDistance || (length - distance) / length <= 0.4)
+            continue;
+        bestDistance = distance;
+        best = name;
+    }
+    return best;
+}
+export function resolveHelpPath(program, argv) {
+    const walk = walkCommandPath(program, argv);
+    const cliAtRoot = walk.unknown === "cli" && walk.path.length === 0;
+    if (cliAtRoot) {
+        const stripped = stripRootCommand(program, argv, "cli");
+        return {
+            kind: "unknown",
+            token: "cli",
+            tryCommand: stripped && stripped.length > 0 ? stripped.join(" ") : undefined,
+        };
+    }
+    if (!walk.helpRequested)
+        return { kind: "passthrough" };
+    if (walk.unknown === "run" && walk.path.length === 0)
+        return { kind: "run-help" };
+    if (walk.unknown) {
+        return {
+            kind: "unknown",
+            token: walk.unknown,
+            suggestion: suggestCommand(walk.command, walk.unknown),
+        };
+    }
+    return { kind: "help", command: walk.command };
+}
+export function formatUnknownCommandError(result) {
+    const lines = [`error: unknown command '${result.token}'`];
+    if (result.tryCommand)
+        lines.push(`Try: cohub ${result.tryCommand}`);
+    else if (result.token === "cli")
+        lines.push(`cohub has no "cli" subcommand. See cohub --help`);
+    else if (result.suggestion)
+        lines.push(`(Did you mean ${result.suggestion}?)`);
+    return `${lines.join("\n")}\n`;
+}

package/dist/http-put.d.ts

@@ -0,0 +1,25 @@
+export declare class HttpPutError extends Error {
+    readonly status: number;
+    readonly body: string;
+    constructor(message: string, status: number, body?: string);
+}
+export type PutRetryOptions = {
+    attempts?: number;
+    delayMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+    fetch?: typeof fetch;
+};
+export declare function putLocalFile(input: PutRetryOptions & {
+    url: string;
+    filePath: string;
+    size: number;
+    headers?: HeadersInit;
+    label: string;
+}): Promise<void>;
+export declare function putBytes(input: PutRetryOptions & {
+    url: string;
+    body: Blob;
+    size?: number;
+    headers?: HeadersInit;
+    label: string;
+}): Promise<void>;

package/dist/http-put.js

@@ -0,0 +1,132 @@
+import { createReadStream } from "node:fs";
+const DEFAULT_ATTEMPTS = 3;
+const DEFAULT_DELAY_MS = 200;
+const RETRYABLE_STATUS = new Set([408, 411, 425, 429, 500, 502, 503, 504]);
+const RETRYABLE_CODES = new Set([
+    "BodyTimeoutError",
+    "ConnectTimeoutError",
+    "EAI_AGAIN",
+    "ECONNREFUSED",
+    "ECONNRESET",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "ENOTFOUND",
+    "EPIPE",
+    "ETIMEDOUT",
+    "HeadersTimeoutError",
+    "UND_ERR_BODY_TIMEOUT",
+    "UND_ERR_CONNECT",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "UND_ERR_HEADERS_TIMEOUT",
+    "UND_ERR_SOCKET",
+]);
+export class HttpPutError extends Error {
+    status;
+    body;
+    constructor(message, status, body = "") {
+        super(message);
+        this.name = "HttpPutError";
+        this.status = status;
+        this.body = body;
+    }
+}
+function withContentLength(headers, contentLength) {
+    const result = new Headers(headers);
+    if (contentLength !== undefined && !result.has("content-length")) {
+        result.set("content-length", String(contentLength));
+    }
+    return result;
+}
+function errorCode(error) {
+    if (!error || typeof error !== "object")
+        return undefined;
+    const record = error;
+    if (typeof record.code === "string")
+        return record.code;
+    if (typeof record.cause?.code === "string")
+        return record.cause.code;
+    if (typeof record.cause?.name === "string")
+        return record.cause.name;
+    if (typeof record.name === "string")
+        return record.name;
+    return undefined;
+}
+function isRetryableError(error) {
+    const code = errorCode(error);
+    return Boolean(code && RETRYABLE_CODES.has(code));
+}
+function isRetryableStatus(status) {
+    return RETRYABLE_STATUS.has(status);
+}
+function defaultSleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function failureMessage(label, status, detail) {
+    return `Failed to upload ${label}: HTTP ${status}${detail ? ` — ${detail}` : ""}`;
+}
+async function putWithRetry(input) {
+    const attempts = input.attempts ?? DEFAULT_ATTEMPTS;
+    const delayMs = input.delayMs ?? DEFAULT_DELAY_MS;
+    const sleep = input.sleep ?? defaultSleep;
+    const fetchImpl = input.fetch ?? fetch;
+    let lastError;
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        try {
+            const response = await fetchImpl(input.url, {
+                method: "PUT",
+                headers: withContentLength(input.headers, input.contentLength),
+                body: input.body(),
+                ...(input.duplex ? { duplex: "half" } : {}),
+            });
+            if (response.ok)
+                return response;
+            const detail = await response.text().catch(() => "");
+            const error = new HttpPutError(failureMessage(input.label, response.status, detail), response.status, detail);
+            if (attempt < attempts - 1 && isRetryableStatus(response.status)) {
+                lastError = error;
+                await sleep(delayMs * 2 ** attempt);
+                continue;
+            }
+            throw error;
+        }
+        catch (error) {
+            if (error instanceof HttpPutError)
+                throw error;
+            lastError = error;
+            if (attempt < attempts - 1 && isRetryableError(error)) {
+                await sleep(delayMs * 2 ** attempt);
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw lastError;
+}
+export async function putLocalFile(input) {
+    await putWithRetry({
+        url: input.url,
+        body: () => createReadStream(input.filePath),
+        headers: input.headers,
+        contentLength: input.size,
+        duplex: true,
+        label: input.label,
+        attempts: input.attempts,
+        delayMs: input.delayMs,
+        sleep: input.sleep,
+        fetch: input.fetch,
+    });
+}
+export async function putBytes(input) {
+    const body = input.body;
+    await putWithRetry({
+        url: input.url,
+        body: () => body,
+        headers: input.headers,
+        contentLength: input.size,
+        label: input.label,
+        attempts: input.attempts,
+        delayMs: input.delayMs,
+        sleep: input.sleep,
+        fetch: input.fetch,
+    });
+}

package/dist/index.js

@@ -16,11 +16,12 @@ import { registerSearch } from "./commands/search.js";
 import { registerReferences } from "./commands/references.js";
 import { registerReferrals } from "./commands/referrals.js";
 import { registerPrompt, registerSpaces } from "./commands/spaces.js";
-import { maybeHandleRunCommand } from "./commands/run.js";
+import { maybeHandleRunCommand, printRunHelp } from "./commands/run.js";
 import { registerSandbox } from "./commands/sandbox.js";
 import { registerTasks } from "./commands/tasks.js";
 import { registerDesktop, registerLegacyUi } from "./commands/desktop.js";
 import { registerApps } from "./commands/apps.js";
+import { formatUnknownCommandError, resolveHelpPath } from "./help-path.js";
 const VERSION = (() => {
     try {
         const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
@@ -41,6 +42,10 @@ program
     .helpOption("-h, --help", "Show help")
     .addHelpText("after", `
 
+Help:
+  cohub apps publish --help
+  cohub help apps publish
+
 Common commands:
   cohub auth login
   cohub profile avatar ./avatar.png
@@ -69,6 +74,7 @@ Environment:
   COHUB_SPACE_ID         Target Space ID when -s is omitted
   COHUB_EXECUTION_TOKEN  Use this token instead of the stored Logto session
   ENV=dev                Use the development Cohub environment
+  HTTPS_PROXY            Honored for API and uploads (also HTTP_PROXY, NO_PROXY)
 `);
 registerAuth(program);
 registerBoards(program);
@@ -92,7 +98,20 @@ registerApps(program);
 registerDesktop(program);
 registerLegacyUi(program);
 const argv = process.argv.slice(2);
-if (await maybeHandleRunCommand(argv)) {
+const help = resolveHelpPath(program, argv);
+if (help.kind === "help") {
+    help.command.outputHelp();
+}
+else if (help.kind === "run-help") {
+    printRunHelp();
+}
+else if (help.kind === "unknown") {
+    process.stderr.write(formatUnknownCommandError(help));
+    process.exit(1);
+}
+else if (await maybeHandleRunCommand(argv)) {
     process.exit();
 }
-program.parse();
+else {
+    program.parse();
+}

package/dist/launcher.d.ts

@@ -1,2 +1,4 @@
 export declare function exitCodeForChild(code: number | null, signal: NodeJS.Signals | null): number;
-export declare function relaunchCli(entrypoint: string, argv: string[]): Promise<number>;
+export declare function relaunchCli(entrypoint: string, argv: string[], options?: {
+    execArgv?: readonly string[];
+}): Promise<number>;

package/dist/launcher.js

@@ -8,9 +8,9 @@ export function exitCodeForChild(code, signal) {
         return 1;
     return 128 + (constants.signals[signal] ?? 1);
 }
-export function relaunchCli(entrypoint, argv) {
+export function relaunchCli(entrypoint, argv, options) {
     return new Promise((resolve, reject) => {
-        const child = spawn(process.execPath, [entrypoint, ...argv], {
+        const child = spawn(process.execPath, [...(options?.execArgv ?? []), entrypoint, ...argv], {
             env: process.env,
             stdio: "inherit",
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "6.8.0",
+  "version": "6.8.2",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "license": "Apache-2.0",
@@ -19,7 +19,7 @@
     "commander": "^15.0.0",
     "pixi.js": "^8.20.1",
     "sharp": "^0.35.4",
-    "@neta-art/cohub": "8.10.1"
+    "@neta-art/cohub": "8.11.0"
   },
   "publishConfig": {
     "access": "public"