@neta-art/cohub-cli 8.4.1 → 9.0.0

package/dist/commands/spaces.js

@@ -1,14 +1,15 @@
-import { randomUUID } from "node:crypto";
 import { readdir, stat } from "node:fs/promises";
 import { basename, dirname, relative, resolve, sep } from "node:path";
-import { resolveCohubEnvironment } from "@neta-art/cohub";
+import { readSentTurns, readSessionTurnOrigin, 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, truncateText } from "../output.js";
 import { resolveSpace } from "../space.js";
+import { uploadLocalFiles } from "../space-files/upload.js";
 import { registerSpaceCommerce } from "./space-commerce.js";
+import { registerSpaceFileTransfer } from "./space-files.js";
 import { registerSpaceActivity } from "./space-activity.js";
+import { registerSpaceDisplays } from "./space-displays.js";
 import { registerSpaceInvitations } from "./space-invitations.js";
 import { registerSpaceTurns } from "./space-turns.js";
 import { registerSpaceWebhooks } from "./space-webhooks.js";
@@ -121,16 +122,8 @@ const walkUploadPath = async (localPath, root) => {
     }
     if (!info.isFile())
         return [];
-    return [{
-            id: randomUploadEntryId(),
-            localPath,
-            relativePath,
-            name,
-            size: info.size,
-            mimeType: null,
-        }];
+    return [{ localPath, relativePath, size: info.size }];
 };
-const randomUploadEntryId = () => randomUUID();
 // Upload semantics: a file keeps its name, and a directory contributes its
 // contents directly under the target dir — like `aws s3 cp dir remote:path`
 // or `rclone copy`.
@@ -158,45 +151,14 @@ export async function collectUploadFiles(paths) {
     }
     return files;
 }
-async function putUploadEntry(entry, uploadUrl, headers) {
-    await putLocalFile({
-        url: uploadUrl,
-        filePath: entry.localPath,
-        size: entry.size,
-        headers,
-        label: entry.relativePath,
-    });
-}
 async function uploadFiles(command, paths, opts) {
     const spaceId = await resolveSpace(command);
     const client = createClient();
     try {
         const files = await collectUploadFiles(paths);
-        const plan = await client.space(spaceId).files.createUpload({
-            destination: { kind: "workspace", targetDir: opts.dir },
-            entries: files.map((file) => ({
-                id: file.id,
-                name: file.name,
-                relativePath: file.relativePath,
-                size: file.size,
-                mimeType: file.mimeType,
-            })),
-        });
-        const byId = new Map(files.map((file) => [file.id, file]));
-        for (const entry of plan.entries) {
-            const file = byId.get(entry.id);
-            if (!file)
-                throw new Error(`Missing upload entry: ${entry.id}`);
-            // Remote downloadUrl entries have no uploadUrl; complete pulls them server-side.
-            if (!entry.uploadUrl)
-                continue;
-            await putUploadEntry(file, entry.uploadUrl, entry.headers);
-        }
-        const result = await client.space(spaceId).files.completeUpload(plan.uploadId, {
-            entries: plan.entries.map((entry) => ({ id: entry.id })),
-        });
+        const { uploaded, uploadIds } = await uploadLocalFiles(client.space(spaceId).files, files, { targetDir: opts.dir });
         if (jsonRequested(opts))
-            return outJson({ ...result, uploadId: plan.uploadId, files: files.length });
+            return outJson({ ok: true, uploaded, uploadId: uploadIds[0], uploadIds, files: files.length });
         ok(`Uploaded ${files.length} file${files.length === 1 ? "" : "s"}`);
     }
     catch (e) {
@@ -242,7 +204,7 @@ async function sendPrompt(command, words, opts) {
         && !new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]).has(thinkingLevel)) {
         return error("Invalid thinking level", "Use off|minimal|low|medium|high|xhigh|max");
     }
-    const spaceId = await resolveSpace(command);
+    const spaceId = await resolveSpace(command, { home: true });
     const client = createClient();
     try {
         const schedule = opts.delayMs
@@ -305,7 +267,7 @@ async function sendPrompt(command, words, opts) {
     }
 }
 async function runCompletionCommand(command, words, opts) {
-    const spaceId = await resolveSpace(command);
+    const spaceId = await resolveSpace(command, { home: true });
     const content = words.join(" ").trim();
     if (!content && process.stdin.isTTY) {
         return error("Message required", "Pass content args or pipe via stdin");
@@ -447,9 +409,66 @@ export function registerSpaceCreate(spacesCmd, dependencies = {}) {
         }
     });
 }
+function registerUserLabels(program) {
+    const labels = program.command("labels").description("Manage personal labels");
+    labels.command("ls").description("List personal labels").option("--json", "Output as JSON").action(async (opts) => {
+        const client = createClient();
+        try {
+            const result = await client.user.labels.list();
+            const flatten = (items, parent = "") => items.flatMap((item) => [
+                { id: item.id, ref: parent ? `${parent}/${item.name}` : item.name, source: item.source, rank: item.rank },
+                ...flatten(item.children ?? [], parent ? `${parent}/${item.name}` : item.name),
+            ]);
+            const rows = flatten(result.labels);
+            if (jsonRequested(opts))
+                return outJson(rows);
+            table(rows, [{ key: "ref", label: "Label" }, { key: "source", label: "Source" }, { key: "rank", label: "Rank" }]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    labels.command("create <ref>").description("Create a personal label").action(async (ref) => {
+        try {
+            await createClient().user.labels.create(ref);
+            ok(`Created label: ${ref}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    labels.command("rename <ref> <name>").description("Rename a personal label").action(async (ref, name) => {
+        try {
+            await createClient().user.labels.update(ref, { name });
+            ok(`Renamed label: ${ref}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    labels.command("rm <ref>").description("Delete a personal label").action(async (ref) => {
+        try {
+            await createClient().user.labels.delete(ref);
+            ok(`Deleted label: ${ref}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    labels.command("reorder <refs...>").description("Set personal label order").action(async (refs) => {
+        try {
+            await createClient().user.labels.reorder(refs);
+            ok(`Reordered ${refs.length} label(s)`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+}
 export function registerSpaces(program) {
     const spacesCmd = program.command("spaces").description("Space management");
     registerSpaceInvitations(spacesCmd);
+    registerUserLabels(program);
     // ── spaces ls ──
     spacesCmd
         .command("ls")
@@ -457,20 +476,27 @@ export function registerSpaces(program) {
         .description("List all spaces")
         .option("--mine", "Only spaces you own")
         .option("--pinned", "Only pinned spaces")
+        .option("--archived", "Only archived spaces")
         .option("--json", "Output as JSON")
         .action(async (opts) => {
         const client = createClient();
         try {
-            const [items, me] = await Promise.all([
-                client.spaces.list(),
-                opts.mine ? client.user.getMe() : Promise.resolve(null),
-            ]);
-            const myUuid = me?.uuid ?? null;
+            const items = [];
+            let cursor = null;
+            do {
+                const page = await client.spaces.list({
+                    limit: 100,
+                    cursor,
+                    filter: opts.archived ? "archived" : opts.pinned ? "pinned" : opts.mine ? "mine" : "all",
+                });
+                items.push(...page.items);
+                cursor = page.pageInfo.nextCursor;
+            } while (cursor);
             const filtered = items.filter((item) => {
-                if (opts.mine && myUuid && item.userUuid !== myUuid)
-                    return false;
                 if (opts.pinned && !item.isPinned)
                     return false;
+                if (opts.archived && !item.isArchived)
+                    return false;
                 return true;
             });
             if (jsonRequested(opts))
@@ -487,6 +513,28 @@ export function registerSpaces(program) {
             handleHttp(e);
         }
     });
+    for (const archive of [true, false]) {
+        spacesCmd
+            .command(archive ? "archive <ids...>" : "unarchive <ids...>")
+            .description(archive ? "Archive spaces in your personal view" : "Restore archived spaces")
+            .option("--json", "Output as JSON")
+            .action(async (ids, opts) => {
+            const client = createClient();
+            try {
+                const chunks = Array.from({ length: Math.ceil(ids.length / 200) }, (_, index) => ids.slice(index * 200, (index + 1) * 200));
+                for (const chunk of chunks)
+                    await client.user.labels.patchResources(chunk, archive
+                        ? { addLabelRefs: ["Archived"], removeLabelRefs: ["Pinned"] }
+                        : { removeLabelRefs: ["Archived"] });
+                if (jsonRequested(opts))
+                    return outJson({ ids, archived: archive });
+                ok(`${archive ? "Archived" : "Unarchived"} ${ids.length} space(s)`);
+            }
+            catch (e) {
+                handleHttp(e);
+            }
+        });
+    }
     // ── spaces get ──
     spacesCmd
         .command("get [id]")
@@ -652,6 +700,7 @@ export function registerSpaces(program) {
         .action((words, opts) => runCompletionCommand(spacesCmd, words, opts));
     // ── spaces files ──
     registerFiles(spacesCmd);
+    registerSpaceDisplays(spacesCmd);
     // ── spaces sessions ──
     registerSessions(spacesCmd);
     // ── spaces turns ──
@@ -712,9 +761,9 @@ export function registerSpaces(program) {
             if (jsonRequested(opts))
                 return outJson(usage);
             console.log("\n  Summary:");
-            table([usage.summary], [
+            table([usage.totals], [
                 { key: "totalTokens", label: "Tokens" },
-                { key: "costTotal", label: "Cost ($)" },
+                ...(usage.totals.costTotal ? [{ key: "costTotal", label: "Cost ($)" }] : []),
                 { key: "requestCount", label: "Requests" },
                 { key: "successCount", label: "Success" },
                 { key: "errorCount", label: "Errors" },
@@ -1145,25 +1194,7 @@ function registerFiles(spacesCmd) {
             handleHttp(e);
         }
     });
-    filesCmd
-        .command("cat <path>")
-        .description("Read file content")
-        .action(async (path) => {
-        const spaceId = await resolveSpace(spacesCmd);
-        const client = createClient();
-        try {
-            const file = await client.space(spaceId).files.read(path);
-            if (!("content" in file))
-                return error("File is being prepared. Please retry shortly.");
-            if (file.delivery === "url" && file.url) {
-                console.log(`[CDN] ${file.url}`);
-            }
-            console.log(file.content);
-        }
-        catch (e) {
-            handleHttp(e);
-        }
-    });
+    registerSpaceFileTransfer(filesCmd, spacesCmd);
     filesCmd
         .command("write <path>")
         .description("Write file content")
@@ -1354,6 +1385,37 @@ function registerSessions(spacesCmd) {
             handleHttp(e);
         }
     });
+    sessionsCmd
+        .command("stats <id>")
+        .description("Session statistics for settled turns (including separate inherited history)")
+        .option("--json", "Output as JSON")
+        .action(async (id, opts) => {
+        const spaceId = await resolveSpace(spacesCmd);
+        try {
+            const { stats } = await createClient().space(spaceId).session(id).stats();
+            if (jsonRequested(opts))
+                return outJson({ stats });
+            const own = stats.own;
+            const rows = [
+                { metric: "Turns", value: own.turns },
+                { metric: "Model calls", value: own.calls },
+                { metric: "Tool calls", value: own.toolCalls },
+                { metric: "Compactions", value: own.compactions },
+                { metric: "Tokens", value: own.usage?.totalTokens },
+                { metric: "Execution time (ms)", value: own.elapsedMs },
+                { metric: "Model time (ms)", value: own.modelMs == null ? null : Math.round(own.modelMs) },
+                { metric: "Model cost (USD)", value: own.modelCostUsd },
+                { metric: "Content generation cost (USD)", value: own.generationCostUsd },
+                { metric: "Inherited turns", value: stats.inherited.turns },
+            ].filter((row) => row.value != null);
+            table(rows, [{ key: "metric", label: "Metric" }, { key: "value", label: "Value" }]);
+            if (own.partial)
+                console.log("Some execution details were not recorded.");
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
     sessionsCmd
         .command("files <id>")
         .description("List Space files changed by a session")
@@ -1514,6 +1576,15 @@ function registerTurns(sessionsCmd) {
                 { key: "stopReason", label: "Stop" },
                 { key: "errorMessage", label: "Error" },
             ]);
+            const origin = readSessionTurnOrigin(result.turn.meta, spaceId);
+            if (origin)
+                console.log(`\nOrigin (${origin.kind}): space=${origin.spaceId} session=${origin.sessionId} turn=${origin.turnId}${origin.toolCallId ? ` toolCall=${origin.toolCallId}` : ""}`);
+            const sent = readSentTurns(result.turn.meta);
+            if (sent.length > 0) {
+                console.log(`\nSent (${sent.length}):`);
+                for (const ref of sent)
+                    console.log(`  ${ref.spaceId ? `space=${ref.spaceId} ` : ""}session=${ref.sessionId} turn=${ref.turnId}${ref.toolCallId ? ` toolCall=${ref.toolCallId}` : ""}`);
+            }
             if (result.turn.userText)
                 console.log(`\nUser:\n${result.turn.userText}`);
             if (result.turn.assistantText)

package/dist/index.js

@@ -37,7 +37,7 @@ program
     .summary("Work with Cohub from your terminal")
     .description("Send prompts, manage Space files, and publish public output.")
     .version(VERSION, "-v, --version", "Show version")
-    .option("-s, --space <id>", "Target Space ID")
+    .option("-s, --space <space>", "Target Space: ID, slug, or username/slug")
     .option("--json", "Print machine-readable JSON when supported")
     .helpOption("-h, --help", "Show help")
     .addHelpText("after", `
@@ -59,7 +59,7 @@ Common commands:
   cohub -s <space-id> boards inspect <board-id>
   cohub -s <space-id> spaces turns ls --author others
   cohub -s <space-id> spaces sessions turns ls <session-id>
-  cohub -s <space-id> spaces files ls
+  cohub -s home spaces files ls
   cohub -s <space-id> public upload ./dist demo
   cohub -s <space-id> apps publish demo --file dist/index.html
   cohub desktop open <app-id> --call selection.get
@@ -69,10 +69,13 @@ Common commands:
   cohub generate "A calm lake at sunrise" --model <model> --output lake.png
 
 Target space:
-  -s <space-id>, then COHUB_SPACE_ID, then the current directory Runtime binding, then Home
+  -s <space>, then COHUB_SPACE_ID, then the current directory Runtime binding.
+  <space> is an ID, a slug you own such as home, or username/slug.
+  prompt, completion, generate, apps, and public fall back to your Home Space;
+  other Space commands need a target.
 
 Environment:
-  COHUB_SPACE_ID         Target Space ID when -s is omitted
+  COHUB_SPACE_ID         Target Space 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)

package/dist/runtime/launch.d.ts

@@ -8,6 +8,7 @@ export type RuntimeUpOptions = {
     harness: string[];
     pi?: string;
     codex?: string;
+    display?: string | boolean;
     yes?: boolean;
     json?: boolean;
     detach?: boolean;
@@ -15,6 +16,7 @@ export type RuntimeUpOptions = {
 };
 export declare const resolveLocalSpaceName: (root: string, name?: string) => string;
 export declare function parseRuntimeHarnesses(values: string[]): ("pi" | "codex")[];
+export declare function parseRuntimeDisplay(value: string | boolean | undefined): string | undefined;
 export declare function resolveRuntimeTarget(program: Command, target?: string): Promise<string>;
 export declare function startBackgroundRuntime(config: RuntimeLaunch): Promise<RuntimeSummary>;
 export declare function runtimeUp(program: Command, dir: string | undefined, options: RuntimeUpOptions): Promise<void>;

package/dist/runtime/launch.js

@@ -7,7 +7,7 @@ import { isLocalHarness } from "@neta-art/cohub";
 import { discoverHarnesses, installedHarnesses } from "./harness.js";
 import { requireAccessToken } from "../auth.js";
 import { createClient } from "../client.js";
-import { currentIdentityKey, explicitSpace } from "../space.js";
+import { currentIdentityKey, explicitSpace, resolveSpaceRef } from "../space.js";
 import { canonicalRuntimeRoot, getRuntimeSpaceBinding, resolveRuntimeSpace } from "./space-binding.js";
 import { controlRuntimeInstance, requestRuntimeInstance, runtimeInstanceDirectory } from "./instance.js";
 import { ensureNativeSync, repairIntegrations } from "./native/attach.js";
@@ -20,10 +20,30 @@ export function parseRuntimeHarnesses(values) {
         throw new Error("Harness must be pi or codex");
     return [...new Set(names.length ? names : ["pi"])];
 }
+export function parseRuntimeDisplay(value) {
+    if (value === undefined || value === false)
+        return undefined;
+    const spec = value === true ? "auto" : value.trim();
+    if (!/^(auto|macos|x11(:[\w.:-]+)?|xvfb(:\d{3,4}x\d{3,4})?)$/.test(spec)) {
+        throw new Error("Display must be auto, macos, x11[:display] or xvfb[:WIDTHxHEIGHT]");
+    }
+    if (process.platform === "linux" && spec === "auto" && !process.env.DISPLAY) {
+        throw new Error(process.env.WAYLAND_DISPLAY
+            ? "Wayland sessions cannot be shared yet: log in with an X11 session, or use --display xvfb for a virtual screen"
+            : "No X11 session to share (DISPLAY is unset): use --display xvfb for a virtual screen");
+    }
+    return spec;
+}
+const isVirtualDisplay = (spec) => spec.startsWith("xvfb");
+async function requestedRuntimeSpace(program, target) {
+    const ref = target?.trim() || explicitSpace(program);
+    return ref ? resolveSpaceRef(ref) : null;
+}
 export async function resolveRuntimeTarget(program, target) {
-    const spaceId = target?.trim() || explicitSpace(program) || (await getRuntimeSpaceBinding(process.cwd(), currentIdentityKey()))?.spaceId;
+    const spaceId = await requestedRuntimeSpace(program, target)
+        ?? (await getRuntimeSpaceBinding(process.cwd(), currentIdentityKey()))?.spaceId;
     if (!spaceId)
-        throw new Error("No directory binding. Use --space <id> or runtime up");
+        throw new Error("No directory binding. Use --space <space> or runtime up");
     return spaceId;
 }
 export async function startBackgroundRuntime(config) {
@@ -72,11 +92,12 @@ export async function runtimeUp(program, dir, options) {
     if (!(await stat(requestedRoot)).isDirectory())
         throw new Error("Workspace is not a directory");
     const root = await canonicalRuntimeRoot(requestedRoot);
-    const requested = options.space?.trim() || explicitSpace(program);
-    if (options.new && requested)
+    const requestedRef = options.space?.trim() || explicitSpace(program);
+    if (options.new && requestedRef)
         throw new Error("--new cannot be combined with --space or COHUB_SPACE_ID");
-    if (options.name && requested)
+    if (options.name && requestedRef)
         throw new Error("--name only applies to a new Space");
+    const requested = await requestedRuntimeSpace(program, options.space);
     const identity = currentIdentityKey();
     if (!identity) {
         await requireAccessToken();
@@ -85,10 +106,11 @@ export async function runtimeUp(program, dir, options) {
     const binding = await getRuntimeSpaceBinding(root, identity);
     const existingId = requested || binding?.spaceId;
     let harnesses = parseRuntimeHarnesses(options.harness);
+    let display = parseRuntimeDisplay(options.display);
     if (existingId && !options.new) {
         const existing = await requestRuntimeInstance(runtimeInstanceDirectory(identity, existingId));
         if (existing) {
-            if (existing.root !== root || options.harness.length && [...existing.harnesses].sort().join() !== [...harnesses].sort().join() || options.pi || options.codex) {
+            if (existing.root !== root || options.harness.length && [...existing.harnesses].sort().join() !== [...harnesses].sort().join() || options.pi || options.codex || display && display !== existing.display) {
                 throw new Error("Runtime is running with a different configuration. Use down first");
             }
             // `up` is the single idempotent entry: a reused instance adopts its running
@@ -134,6 +156,11 @@ export async function runtimeUp(program, dir, options) {
             const answer = await rl.question("Collaborators can execute as your OS user, beyond this folder. Allow? [Y/n] ");
             if (/^n(o)?$/i.test(answer.trim()))
                 return;
+            if (display && !isVirtualDisplay(display)) {
+                const share = await rl.question("Collaborators and agents can see and control this screen. Share it? [y/N] ");
+                if (!/^y(es)?$/i.test(share.trim()))
+                    display = undefined;
+            }
         }
         finally {
             rl.close();
@@ -160,7 +187,7 @@ export async function runtimeUp(program, dir, options) {
     });
     // Consent (or --yes) precedes any user-level integration install; failure never blocks startup.
     const native = await ensureNativeSync({ root, spaceId, identity, harnesses, yes: options.yes, executables: { pi: options.pi, codex: options.codex } });
-    const config = { spaceId, root, identity, harnesses, capabilities, executables: { pi: options.pi, codex: options.codex }, background: Boolean(options.detach), verbose: options.verbose, importHistory: native.importHistory };
+    const config = { spaceId, root, identity, harnesses, capabilities, executables: { pi: options.pi, codex: options.codex }, background: Boolean(options.detach), verbose: options.verbose, importHistory: native.importHistory, display };
     const existing = await requestRuntimeInstance(runtimeInstanceDirectory(identity, spaceId));
     if (existing) {
         if (existing.root !== root)

package/dist/runtime/presentation.d.ts

@@ -18,6 +18,7 @@ export type RuntimeSummary = {
     workspaceConnected: boolean;
     diagnosticsPath: string;
     background: boolean;
+    display?: string;
     native?: NativeStatus;
 };
 export declare function printRuntimeSummary(summary: RuntimeSummary, json?: boolean, reused?: boolean): void;

package/dist/runtime/presentation.js

@@ -1,7 +1,7 @@
-import { resolveCohubEnvironment } from "@neta-art/cohub";
+import { webUrl } from "../web.js";
 export const diagnosticLevels = ["debug", "info", "warn", "error"];
 export const atLeastLevel = (level, minimum) => diagnosticLevels.indexOf(level) >= diagnosticLevels.indexOf(minimum);
-export const runtimeWebUrl = (spaceId) => `https://${resolveCohubEnvironment() === "prod" ? "" : "dev."}cohub.live/spaces/${spaceId}`;
+export const runtimeWebUrl = (spaceId) => webUrl(`/spaces/${spaceId}`);
 const messages = {
     "runtime.ready": "Harness connected",
     "runtime.available": "Runtime ready",
@@ -69,6 +69,7 @@ export function printRuntimeSummary(summary, json = false, reused = false) {
         ["Directory", summary.root],
         ["Harness", summary.harnesses.join(" · ")],
         ["Mode", summary.background ? "Background" : "Foreground"],
+        ...(summary.display ? [["Screen", summary.display === "auto" ? "This computer" : summary.display]] : []),
         ["PID", String(summary.pid)],
         ["Logs", summary.diagnosticsPath],
     ];

package/dist/runtime/supervisor.d.ts

@@ -13,6 +13,7 @@ export type RuntimeLaunch = {
     verbose?: boolean;
     /** Start importing earlier conversations as soon as the Runtime is connected. */
     importHistory?: boolean;
+    display?: string;
 };
 export declare function sandboxOutputLevel(value: unknown, stream: "stdout" | "stderr"): RuntimeDiagnosticLevel;
 export declare function runRuntime(config: RuntimeLaunch, onState: (status: RuntimeSummary) => void, externalSignal?: AbortSignal, onDiagnostic?: (event: RuntimeDiagnostic) => void): Promise<void>;

package/dist/runtime/supervisor.js

@@ -48,6 +48,7 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
     let status = {
         spaceId: config.spaceId, root: config.root, runtimeId: diagnostics.runtimeId,
         pid: process.pid, harnesses: config.harnesses, background: config.background,
+        ...(config.display ? { display: config.display } : {}),
         state: "starting", harnessConnected: false, workspaceConnected: false,
         diagnosticsPath: diagnostics.directory,
     };
@@ -123,7 +124,7 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
                     signal.throwIfAborted();
                     const bridge = spawn(binary, ["--local", "--space", config.spaceId, "--root", config.root, "--relay", process.env.COHUB_RELAY_URL?.trim() || relay.toString()], {
                         stdio: ["pipe", "pipe", "pipe", "pipe"],
-                        env: { ...process.env, COHUB_RELAY_TOKEN: initialToken, COHUB_RUNTIME_ID: status.runtimeId, COHUB_LOG_FORMAT: "json", COHUB_RUNTIME_MANAGED: "1" },
+                        env: { ...process.env, COHUB_RELAY_TOKEN: initialToken, COHUB_RUNTIME_ID: status.runtimeId, COHUB_LOG_FORMAT: "json", COHUB_RUNTIME_MANAGED: "1", COHUB_DISPLAY: config.display ?? "" },
                     });
                     bridge.stdin?.on("error", () => undefined);
                     const closed = new Promise((resolve) => {

package/dist/space-files/limit.d.ts

@@ -0,0 +1,2 @@
+export type Limiter = <T>(task: () => Promise<T>) => Promise<T>;
+export declare function createLimiter(concurrency: number): Limiter;

package/dist/space-files/limit.js

@@ -0,0 +1,16 @@
+export function createLimiter(concurrency) {
+    let active = 0;
+    const waiting = [];
+    return async (task) => {
+        if (active >= concurrency)
+            await new Promise((resolve) => waiting.push(resolve));
+        active += 1;
+        try {
+            return await task();
+        }
+        finally {
+            active -= 1;
+            waiting.shift()?.();
+        }
+    };
+}

package/dist/space-files/operands.d.ts

@@ -0,0 +1,16 @@
+export type SpaceOperand = {
+    kind: "space";
+    space: string | null;
+    path: string;
+};
+export type LocalOperand = {
+    kind: "local";
+    path: string;
+};
+export type FileOperand = SpaceOperand | LocalOperand;
+export declare class InvalidFileOperandError extends Error {
+    name: string;
+}
+export declare function normalizeSpacePath(raw: string): string;
+export declare function parseSpaceFileOperand(raw: string): SpaceOperand;
+export declare function parseCopyOperand(raw: string, currentSpaceDeclared: boolean): FileOperand;

package/dist/space-files/operands.js

@@ -0,0 +1,33 @@
+import { posix, resolve } from "node:path";
+import { parseSpaceRef } from "@neta-art/cohub";
+export class InvalidFileOperandError extends Error {
+    name = "InvalidFileOperandError";
+}
+const WORKSPACE_ROOT = "/workspace";
+const isWorkspacePath = (path) => path === WORKSPACE_ROOT || path.startsWith(`${WORKSPACE_ROOT}/`);
+export function normalizeSpacePath(raw) {
+    let path = raw.trim();
+    if (isWorkspacePath(path))
+        path = path.slice(WORKSPACE_ROOT.length + 1);
+    else if (path.startsWith("/"))
+        throw new InvalidFileOperandError(`'${raw}' is not a Space path`);
+    const normalized = posix.normalize(path || ".").replace(/\/+$/, "");
+    return normalized === "." ? "" : normalized;
+}
+function parseSpacePrefix(raw) {
+    const colon = raw.indexOf(":");
+    if (colon <= 0)
+        return null;
+    const space = raw.slice(0, colon);
+    return parseSpaceRef(space) ? { kind: "space", space, path: normalizeSpacePath(raw.slice(colon + 1)) } : null;
+}
+export function parseSpaceFileOperand(raw) {
+    return parseSpacePrefix(raw) ?? { kind: "space", space: null, path: normalizeSpacePath(raw) };
+}
+export function parseCopyOperand(raw, currentSpaceDeclared) {
+    const space = parseSpacePrefix(raw);
+    if (space)
+        return space;
+    const local = !currentSpaceDeclared || (raw.startsWith("/") && !isWorkspacePath(raw));
+    return local ? { kind: "local", path: resolve(raw) } : { kind: "space", space: null, path: normalizeSpacePath(raw) };
+}

package/dist/space-files/transfer.d.ts

@@ -0,0 +1,53 @@
+import { type SpaceFsCopyResult, type SpaceFsCopyStats, type SpaceFsTreeResponse } from "@neta-art/cohub";
+import { type SpaceFiles } from "./upload.js";
+export type CopyOptions = {
+    recursive: boolean;
+    noClobber: boolean;
+    preserveTimestamps: boolean;
+};
+export declare class CopyAbortError extends Error {
+    name: string;
+}
+export declare const emptyCopyResult: () => SpaceFsCopyResult;
+export declare function mergeCopyResults(results: SpaceFsCopyResult[]): SpaceFsCopyResult;
+type SpaceNode = {
+    type: "dir";
+    tree: SpaceFsTreeResponse;
+} | {
+    type: "file";
+} | null;
+export declare function statSpacePath(files: SpaceFiles, path: string): Promise<SpaceNode>;
+export declare function checkDestination(input: {
+    sourceCount: number;
+    display: string;
+    stat: (path: string) => Promise<"dir" | "file" | null>;
+    path: string;
+    parent: string;
+}): Promise<boolean>;
+export declare const spaceNodeType: (files: SpaceFiles, path: string) => Promise<"dir" | "file" | null>;
+export declare const localNodeType: (path: string) => Promise<"dir" | "file" | null>;
+export declare function uploadToSpace(input: {
+    files: SpaceFiles;
+    sources: string[];
+    destination: string;
+    intoDirectory: boolean;
+    options: CopyOptions;
+    onProgress: (stats: SpaceFsCopyStats) => void;
+}): Promise<SpaceFsCopyResult>;
+export declare function downloadFromSpace(input: {
+    sources: Array<{
+        files: SpaceFiles;
+        path: string;
+    }>;
+    destination: string;
+    intoDirectory: boolean;
+    options: CopyOptions;
+    onProgress: (stats: SpaceFsCopyStats) => void;
+}): Promise<SpaceFsCopyResult>;
+export declare function copyLocal(input: {
+    sources: string[];
+    destination: string;
+    intoDirectory: boolean;
+    options: CopyOptions;
+}): Promise<SpaceFsCopyResult>;
+export {};