@neta-art/cohub-cli 8.4.1 → 9.0.0

package/dist/commands/space-displays.js

@@ -0,0 +1,347 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { compileDisplayActions, DISPLAY_ELEMENT_REF_PATTERN, DISPLAY_SYSTEM_ACTIONS, DisplayActionError, } from "@neta-art/cohub";
+import { createClient } from "../client.js";
+import { error, handleHttp, json as outJson, jsonRequested, ok, table } from "../output.js";
+import { resolveSpace } from "../space.js";
+import { webUrl } from "../web.js";
+const DIRECTIONS = ["up", "down", "left", "right"];
+const BUTTONS = ["primary", "secondary", "middle"];
+const DEFAULT_MAX_SIZE = 1280;
+const SETTLE_MS = 600;
+const FRAMES_PATH = join(homedir(), ".cache", "cohub-cli", "display-frames.json");
+const NO_DISPLAY_HINT = "Share one first: the Android app's Runtime menu, `cohub runtime up --display` on a computer, or `cohub spaces displays start` for a virtual screen.";
+function parseSize(value) {
+    const match = /^(\d{1,5})x(\d{1,5})$/i.exec(value.trim());
+    const width = Number(match?.[1]);
+    const height = Number(match?.[2]);
+    if (!match || width < 1 || height < 1)
+        return error("Invalid size", "Use WIDTHxHEIGHT, e.g. 576x1280.");
+    return { width, height };
+}
+function parseNumber(name, value) {
+    const number = Number(value);
+    if (!Number.isFinite(number))
+        return error(`Invalid ${name}`, `${name} must be a number.`);
+    return number;
+}
+function isRef(value) {
+    return DISPLAY_ELEMENT_REF_PATTERN.test(value);
+}
+async function readFrames() {
+    try {
+        return JSON.parse(await readFile(FRAMES_PATH, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+async function rememberFrame(spaceId, display, size) {
+    const frames = await readFrames();
+    frames[`${spaceId}/${display.id}`] = { width: size.width, height: size.height, display: { width: display.width, height: display.height } };
+    await mkdir(dirname(FRAMES_PATH), { recursive: true });
+    await writeFile(FRAMES_PATH, JSON.stringify(frames));
+}
+async function frameOf(spaceId, display, size) {
+    if (size)
+        return parseSize(size);
+    const frame = (await readFrames())[`${spaceId}/${display.id}`];
+    if (frame && frame.display.width === display.width && frame.display.height === display.height)
+        return frame;
+    return { width: display.width, height: display.height };
+}
+function pickDisplay(displays, requested) {
+    if (requested) {
+        const found = displays.find((display) => display.id === requested);
+        if (!found)
+            return error(`Display "${requested}" is not shared`, `Shared displays: ${displays.map((display) => display.id).join(", ") || "none"}`);
+        return found;
+    }
+    if (displays.length === 1 && displays[0])
+        return displays[0];
+    if (displays.length === 0)
+        return error("No display is shared with this Space", NO_DISPLAY_HINT);
+    return error("Several displays are shared", `Pass --display with one of: ${displays.map((display) => display.id).join(", ")}`);
+}
+async function target(spacesCmd, opts) {
+    const spaceId = await resolveSpace(spacesCmd);
+    const api = createClient().space(spaceId).displays;
+    const { displays } = await api.list();
+    return { spaceId, api, display: pickDisplay(displays, opts.display) };
+}
+function displayUrl(spaceId, displayId) {
+    return webUrl(`/spaces/${spaceId}?window=${encodeURIComponent(`display:${displayId}`)}`);
+}
+function needsHint(display) {
+    const needs = display.needs ?? [];
+    if (needs.length === 0)
+        return null;
+    if (!display.desktop)
+        return `${display.name || display.id} needs control: on the phone, choose Allow control in the Space's Runtime menu and enable Cohub in Accessibility settings.`;
+    const names = needs.map((need) => (need === "screenRecording" ? "Screen Recording" : "Accessibility")).join(" and ");
+    return `${display.name || display.id} needs ${names}: allow it for the Runtime's terminal in System Settings → Privacy & Security, then restart the Runtime.`;
+}
+async function screenshot(api, spaceId, display, maxSize, output) {
+    const capture = await api.capture(display.id, { maxSize });
+    const path = resolve(output ?? `${display.id}-${new Date().toISOString().replace(/[:.]/g, "-")}.jpg`);
+    await writeFile(path, Buffer.from(capture.data, "base64"));
+    await rememberFrame(spaceId, display, capture);
+    return { path, width: capture.width, height: capture.height };
+}
+async function act(spacesCmd, opts, actions) {
+    try {
+        const { spaceId, api, display } = await target(spacesCmd, opts);
+        if (!display.input)
+            return error("This display is view only", needsHint(display) ?? "Allow control on the device first.");
+        const frame = await frameOf(spaceId, display, opts.size);
+        const events = compileDisplayActions(actions, frame.width, frame.height);
+        const result = await api.input(display.id, events);
+        let shot;
+        if (opts.screenshot) {
+            await new Promise((done) => setTimeout(done, SETTLE_MS));
+            shot = await screenshot(api, spaceId, display, Math.max(frame.width, frame.height), typeof opts.screenshot === "string" ? opts.screenshot : undefined);
+        }
+        if (jsonRequested(opts))
+            return outJson({ display: display.id, ...result, frame: { width: frame.width, height: frame.height }, ...(shot ? { screenshot: shot } : {}) });
+        ok(`Performed ${actions.length} action${actions.length === 1 ? "" : "s"} on ${display.name || display.id}, in ${frame.width}x${frame.height} pixels`);
+        if (shot)
+            console.log(`  Screenshot ${shot.width}x${shot.height}: ${shot.path}`);
+    }
+    catch (e) {
+        if (e instanceof DisplayActionError)
+            return error("Invalid action", e.message);
+        handleHttp(e);
+    }
+}
+function withTarget(command) {
+    return command
+        .option("-d, --display <id>", "Display id; defaults to the only shared display")
+        .option("--size <WxH>", "Coordinates are pixels of an image this size (default: the latest screenshot)")
+        .option("--screenshot [path]", "Save a screenshot once the screen settles")
+        .option("--json", "Output as JSON");
+}
+function pointOrRef(x, y, command) {
+    if (y === undefined)
+        return isRef(x) ? { ref: x } : error("Invalid target", `Pass x and y, or an element ref from \`cohub spaces displays tree\`, e.g. ${command} e3.12.`);
+    return { x: parseNumber("x", x), y: parseNumber("y", y) };
+}
+function formatTree(tree, frame) {
+    const scaleX = (frame.width - 1) || 1;
+    const scaleY = (frame.height - 1) || 1;
+    return tree.elements
+        .map((element) => {
+        const [x, y, width, height] = element.bounds;
+        const box = `(${Math.round(x * scaleX)},${Math.round(y * scaleY)} ${Math.round(width * scaleX)}x${Math.round(height * scaleY)})`;
+        const parts = [`${"  ".repeat(element.depth)}${element.ref}`, element.role];
+        if (element.name)
+            parts.push(JSON.stringify(element.name));
+        if (element.value)
+            parts.push(`value=${JSON.stringify(element.value)}`);
+        if (element.states?.length)
+            parts.push(`[${element.states.join(", ")}]`);
+        parts.push(box);
+        return parts.join(" ");
+    })
+        .join("\n");
+}
+export function registerSpaceDisplays(spacesCmd) {
+    const displays = spacesCmd
+        .command("displays")
+        .description("Screens shared with a Space: view, read and control")
+        .hook("preAction", async () => { await resolveSpace(spacesCmd); });
+    displays
+        .command("ls")
+        .alias("list")
+        .description("List shared displays and who watches them")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        try {
+            const spaceId = await resolveSpace(spacesCmd);
+            const result = await createClient().space(spaceId).displays.list();
+            if (jsonRequested(opts))
+                return outJson(result);
+            if (result.displays.length === 0)
+                console.log(`  (no shared displays) ${NO_DISPLAY_HINT}`);
+            else {
+                table(result.displays.map((display) => ({
+                    ...display,
+                    size: `${display.width}x${display.height}`,
+                    abilities: [display.stream && "view", display.capture && "capture", display.input && "control", display.tree && "tree", display.desktop && "desktop"].filter(Boolean).join(", "),
+                    watching: display.viewers?.length ? `${display.viewers.length}${display.viewers.some((viewer) => viewer.control) ? " (controlling)" : ""}` : "—",
+                })), [
+                    { key: "id", label: "ID" },
+                    { key: "name", label: "Name" },
+                    { key: "size", label: "Size" },
+                    { key: "abilities", label: "Abilities" },
+                    { key: "watching", label: "Watching" },
+                ]);
+                for (const display of result.displays) {
+                    const hint = needsHint(display);
+                    if (hint)
+                        console.log(`  ${hint}`);
+                }
+            }
+            if (result.virtual)
+                console.log(`  Virtual screen: ${result.virtual === "running" ? "running (cohub spaces displays stop)" : "available (cohub spaces displays start)"}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    displays
+        .command("start")
+        .description("Start the machine's virtual screen, e.g. in a cloud sandbox")
+        .option("--size <WxH>", "Screen size (default 1280x800)")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        try {
+            const spaceId = await resolveSpace(spacesCmd);
+            if (opts.size)
+                parseSize(opts.size);
+            const result = await createClient().space(spaceId).displays.startVirtual(opts.size ? { size: opts.size } : {});
+            const url = result.displays[0] ? displayUrl(spaceId, result.displays[0].id) : null;
+            if (jsonRequested(opts))
+                return outJson({ ...result, url });
+            ok("Virtual screen running; programs started from now on draw on it");
+            if (url)
+                console.log(`  Watch and take over: ${url}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    displays
+        .command("stop")
+        .description("Stop the machine's virtual screen")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        try {
+            const spaceId = await resolveSpace(spacesCmd);
+            const result = await createClient().space(spaceId).displays.stopVirtual();
+            if (jsonRequested(opts))
+                return outJson(result);
+            ok("Virtual screen stopped");
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    displays
+        .command("capture")
+        .description("Save a screenshot; later coordinates are its pixels")
+        .option("-d, --display <id>", "Display id; defaults to the only shared display")
+        .option("-o, --output <path>", "Where to write the image (default: <display>-<time>.jpg)")
+        .option("--max-size <px>", `Longest edge in pixels (default ${DEFAULT_MAX_SIZE})`)
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        try {
+            const { spaceId, api, display } = await target(spacesCmd, opts);
+            const maxSize = opts.maxSize ? parseNumber("max-size", opts.maxSize) : DEFAULT_MAX_SIZE;
+            const shot = await screenshot(api, spaceId, display, maxSize, opts.output);
+            if (jsonRequested(opts))
+                return outJson({ display: display.id, ...shot });
+            ok(`Saved ${shot.width}x${shot.height} screenshot to ${shot.path}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    displays
+        .command("tree")
+        .description("Read the interface as elements: refs to act on, roles, names and boxes")
+        .option("-d, --display <id>", "Display id; defaults to the only shared display")
+        .option("--max <n>", "Most elements to return (default 300)")
+        .option("--actionable", "Only elements that take an action, flat: fewer tokens when looking for a target")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        try {
+            const { spaceId, api, display } = await target(spacesCmd, opts);
+            if (!display.tree)
+                return error("This display has no element tree", "Use capture and coordinates instead.");
+            const tree = await api.tree(display.id, {
+                ...(opts.max ? { maxElements: parseNumber("max", opts.max) } : {}),
+                ...(opts.actionable ? { actionable: true } : {}),
+            });
+            if (jsonRequested(opts))
+                return outJson(tree);
+            const frame = await frameOf(spaceId, display);
+            console.log(formatTree(tree, frame));
+            console.log(`\n  Boxes are x,y and size in ${frame.width}x${frame.height} pixels. Act with: tap <ref> · type <text> --into <ref> · scroll <direction> --in <ref>`);
+            if (tree.truncated)
+                console.log("  More elements exist; pass --max to read more.");
+            if (display.viewers?.some((viewer) => viewer.control))
+                console.log("  A person is watching with control; what you do here pauses while they act.");
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    withTarget(displays.command("tap <x> [y]").description("Tap or click a point, or an element by ref"))
+        .option("--count <n>", "2 to double-click, 3 to triple-click")
+        .option("--button <button>", `Mouse button on a desktop: ${BUTTONS.join(", ")}`)
+        .action((x, y, opts) => {
+        const button = BUTTONS.find((candidate) => candidate === (opts.button ?? "primary"));
+        if (!button)
+            return error("Invalid button", `Use one of: ${BUTTONS.join(", ")}`);
+        return act(spacesCmd, opts, [{
+                type: "tap", ...pointOrRef(x, y, "tap"), button,
+                ...(opts.count ? { count: parseNumber("count", opts.count) } : {}),
+            }]);
+    });
+    withTarget(displays.command("long-press <x> [y]").description("Touch and hold a point, or an element by ref"))
+        .option("--duration <ms>", "Hold time in milliseconds", "800")
+        .action((x, y, opts) => act(spacesCmd, opts, [{ type: "long_press", ...pointOrRef(x, y, "long-press"), duration_ms: parseNumber("duration", opts.duration) }]));
+    withTarget(displays.command("swipe <x1> <y1> <x2> <y2>").description("Swipe from one point to another"))
+        .option("--duration <ms>", "Swipe time in milliseconds", "300")
+        .action((x1, y1, x2, y2, opts) => act(spacesCmd, opts, [{
+            type: "swipe",
+            x: parseNumber("x1", x1), y: parseNumber("y1", y1),
+            to_x: parseNumber("x2", x2), to_y: parseNumber("y2", y2),
+            duration_ms: parseNumber("duration", opts.duration),
+        }]));
+    withTarget(displays.command("scroll <direction>").description("Scroll content up, down, left or right"))
+        .option("--amount <fraction>", "Fraction of the display, 0.1–1", "0.5")
+        .option("--in <ref>", "Scroll this element of the tree")
+        .action((direction, opts) => {
+        if (!DIRECTIONS.includes(direction))
+            return error("Invalid direction", `Use one of: ${DIRECTIONS.join(", ")}`);
+        return act(spacesCmd, opts, [{
+                type: "scroll", direction: direction, amount: parseNumber("amount", opts.amount),
+                ...(opts.in ? { ref: opts.in } : {}),
+            }]);
+    });
+    withTarget(displays.command("type <text>").description("Type into the focused field, or replace an element's text"))
+        .option("--into <ref>", "Replace the text of this element of the tree")
+        .action((text, opts) => act(spacesCmd, opts, [{ type: "type", text, ...(opts.into ? { ref: opts.into } : {}) }]));
+    withTarget(displays.command("key <key>").description("Press a key or shortcut, e.g. Enter or Control+a"))
+        .action((key, opts) => act(spacesCmd, opts, [{ type: "key", key }]));
+    withTarget(displays.command("press <button>").description(`Press a system button: ${DISPLAY_SYSTEM_ACTIONS.join(", ")}`))
+        .action((button, opts) => {
+        const action = DISPLAY_SYSTEM_ACTIONS.find((candidate) => candidate === button);
+        if (!action)
+            return error("Invalid button", `Use one of: ${DISPLAY_SYSTEM_ACTIONS.join(", ")}`);
+        return act(spacesCmd, opts, [{ type: "system", action }]);
+    });
+    withTarget(displays.command("act").description("Run a JSON array of actions from --actions or stdin"))
+        .option("--actions <json>", "Actions, e.g. '[{\"type\":\"tap\",\"x\":540,\"y\":1200},{\"type\":\"tap\",\"ref\":\"e3.12\"}]'")
+        .action(async (opts) => {
+        let raw = opts.actions ?? "";
+        if (!raw && !process.stdin.isTTY) {
+            const chunks = [];
+            for await (const chunk of process.stdin)
+                chunks.push(chunk);
+            raw = Buffer.concat(chunks).toString();
+        }
+        let actions;
+        try {
+            actions = JSON.parse(raw);
+        }
+        catch {
+            return error("Invalid actions", "Pass a JSON array with --actions or on stdin.");
+        }
+        if (!Array.isArray(actions) || actions.length === 0)
+            return error("Invalid actions", "Pass a non-empty JSON array.");
+        return act(spacesCmd, opts, actions);
+    });
+}

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

@@ -0,0 +1,5 @@
+import type { SpaceFsCopyResult, SpaceFsCopyStats } from "@neta-art/cohub";
+import { type Command } from "commander";
+export declare function formatBytes(bytes: number): string;
+export declare function formatCopySummary(result: SpaceFsCopyStats & Pick<SpaceFsCopyResult, "overwritten" | "skipped">): string;
+export declare function registerSpaceFileTransfer(filesCmd: Command, spacesCmd: Command): void;

package/dist/commands/space-files.js

@@ -0,0 +1,215 @@
+import { randomUUID } from "node:crypto";
+import { once } from "node:events";
+import { dirname, posix } from "node:path";
+import { Option } from "commander";
+import { createClient } from "../client.js";
+import { error, json as outJson, jsonRequested, ok } from "../output.js";
+import { explicitSpace, failSpaceTarget, resolveSpace, resolveSpaceRef } from "../space.js";
+import { InvalidFileOperandError, parseCopyOperand, parseSpaceFileOperand, } from "../space-files/operands.js";
+import { checkDestination, copyLocal, CopyAbortError, downloadFromSpace, localNodeType, mergeCopyResults, spaceNodeType, uploadToSpace, } from "../space-files/transfer.js";
+function fail(e) {
+    if (e instanceof InvalidFileOperandError || e instanceof CopyAbortError)
+        return error(e.message);
+    return failSpaceTarget(e);
+}
+const operandSpaceResolver = (spacesCmd) => (space) => space ? resolveSpaceRef(space) : resolveSpace(spacesCmd);
+export function formatBytes(bytes) {
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let value = bytes;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    return unit === 0 ? `${value} B` : `${value.toFixed(value < 10 ? 1 : 0)} ${units[unit]}`;
+}
+const count = (value, singular, plural = `${singular}s`) => `${value} ${value === 1 ? singular : plural}`;
+export function formatCopySummary(result) {
+    const parts = [count(result.files, "file")];
+    if (result.dirs)
+        parts.push(count(result.dirs, "directory", "directories"));
+    if (result.symlinks)
+        parts.push(count(result.symlinks, "symlink"));
+    let summary = `${parts.join(", ")} (${formatBytes(result.bytes)})`;
+    if (result.overwritten)
+        summary += `, ${result.overwritten} overwritten`;
+    if (result.skipped)
+        summary += `, ${result.skipped} skipped`;
+    return summary;
+}
+function createProgressLine() {
+    if (!process.stderr.isTTY)
+        return { update: () => undefined, clear: () => undefined };
+    let shown = false;
+    return {
+        update: (progress) => {
+            shown = true;
+            process.stderr.write(`\r\x1b[2K  Copying… ${count(progress.files, "file")} (${formatBytes(progress.bytes)})`);
+        },
+        clear: () => {
+            if (shown)
+                process.stderr.write("\r\x1b[2K");
+        },
+    };
+}
+const spaceParent = (path) => (posix.dirname(path) === "." ? "" : posix.dirname(path));
+async function copyFiles(spacesCmd, raw, opts) {
+    if (raw.length < 2)
+        return error("missing destination operand", "Usage: cohub spaces files cp [-r] <source>... <destination>");
+    const client = createClient();
+    const resolveSpaceId = operandSpaceResolver(spacesCmd);
+    const progress = createProgressLine();
+    const options = {
+        recursive: Boolean(opts.recursive || opts.R),
+        noClobber: opts.clobber === false,
+        preserveTimestamps: Boolean(opts.preserve),
+    };
+    try {
+        const declared = explicitSpace(spacesCmd) !== null;
+        const operands = raw.map((value) => parseCopyOperand(value, declared));
+        const destination = operands.pop();
+        const display = raw.at(-1);
+        const spaceSources = operands.filter((operand) => operand.kind === "space");
+        const localSources = operands.filter((operand) => operand.kind === "local").map((operand) => operand.path);
+        const results = [];
+        if (destination.kind === "space") {
+            const files = client.space(await resolveSpaceId(destination.space)).files;
+            const intoDirectory = await checkDestination({
+                sourceCount: operands.length,
+                display,
+                path: destination.path,
+                parent: spaceParent(destination.path),
+                stat: (path) => spaceNodeType(files, path),
+            });
+            if (spaceSources.length > 0) {
+                const started = await files.copy({
+                    sources: await Promise.all(spaceSources.map(async (source) => ({ spaceId: await resolveSpaceId(source.space), path: source.path }))),
+                    destination: destination.path,
+                    ...options,
+                    mutationId: randomUUID(),
+                });
+                results.push(await files.waitForCopy(started, { pollMs: process.stderr.isTTY ? 2_000 : 10_000, onProgress: progress.update }));
+            }
+            if (localSources.length > 0) {
+                results.push(await uploadToSpace({ files, sources: localSources, destination: destination.path, intoDirectory, options, onProgress: progress.update }));
+            }
+        }
+        else {
+            const intoDirectory = await checkDestination({
+                sourceCount: operands.length,
+                display,
+                path: destination.path,
+                parent: dirname(destination.path),
+                stat: localNodeType,
+            });
+            if (spaceSources.length > 0) {
+                const sources = await Promise.all(spaceSources.map(async (source) => ({
+                    files: client.space(await resolveSpaceId(source.space)).files,
+                    path: source.path,
+                })));
+                results.push(await downloadFromSpace({ sources, destination: destination.path, intoDirectory, options, onProgress: progress.update }));
+            }
+            if (localSources.length > 0) {
+                results.push(await copyLocal({ sources: localSources, destination: destination.path, intoDirectory, options }));
+            }
+        }
+        progress.clear();
+        const result = mergeCopyResults(results);
+        if (jsonRequested(opts)) {
+            outJson(result);
+        }
+        else {
+            for (const failure of result.errors)
+                process.stderr.write(`cp: ${failure.message}\n`);
+            if (result.errors.length === 0 || result.files + result.dirs + result.symlinks > 0)
+                ok(`Copied ${formatCopySummary(result)}`);
+        }
+        if (result.errors.length > 0)
+            process.exit(1);
+    }
+    catch (e) {
+        progress.clear();
+        fail(e);
+    }
+}
+async function writeFileBody(response, path) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        return;
+    let first = true;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            return;
+        if (first && process.stdout.isTTY && value.includes(0)) {
+            await reader.cancel();
+            return error(`'${path}' is a binary file`, `Redirect it to a file: cohub spaces files cat ${path} > <file>`);
+        }
+        first = false;
+        if (!process.stdout.write(value))
+            await once(process.stdout, "drain");
+    }
+}
+async function catFiles(spacesCmd, paths, opts) {
+    process.stdout.on("error", (e) => {
+        if (e.code === "EPIPE")
+            process.exit(0);
+        error(e.message);
+    });
+    const client = createClient();
+    const resolveSpaceId = operandSpaceResolver(spacesCmd);
+    try {
+        const operands = paths.map(parseSpaceFileOperand);
+        if (jsonRequested(opts)) {
+            const files = await Promise.all(operands.map(async (operand) => client.space(await resolveSpaceId(operand.space)).files.read(operand.path)));
+            return outJson(files.length === 1 ? files[0] : files);
+        }
+        for (const operand of operands) {
+            const file = await client.space(await resolveSpaceId(operand.space)).files.open(operand.path);
+            await writeFileBody(file.response, operand.path);
+        }
+    }
+    catch (e) {
+        fail(e);
+    }
+}
+export function registerSpaceFileTransfer(filesCmd, spacesCmd) {
+    filesCmd
+        .command("cat <paths...>")
+        .description("Print file contents; binary-safe when redirected")
+        .option("--json", "Output file metadata and content as JSON")
+        .addHelpText("after", `
+Paths may name another Space as <space>:<path>, where <space> is an id,
+username/slug, or the slug of a Space you own.
+
+Examples:
+  cohub spaces files cat README.md
+  cohub spaces files cat assets/logo.png > logo.png
+  cohub spaces files cat alice/notes:todo.md`)
+        .action((paths, opts) => catFiles(spacesCmd, paths, opts));
+    filesCmd
+        .command("cp <paths...>")
+        .description("Copy files between Spaces and the local filesystem, like scp")
+        .option("-r, --recursive", "Copy directories recursively")
+        .addOption(new Option("-R", "Same as --recursive").hideHelp())
+        .option("-n, --no-clobber", "Do not overwrite existing files")
+        .option("-p, --preserve", "Preserve modification times (not kept by uploads)")
+        .option("--json", "Output the copy result as JSON")
+        .addHelpText("after", `
+Works like scp and cp: the last path is the destination, existing files are
+overwritten and directories merged. <space>:<path> addresses a Space, where
+<space> is an id, username/slug, or the slug of a Space you own; write
+./name for a path that contains a colon.
+
+Bare paths address the current Space when one is declared with -s or
+COHUB_SPACE_ID, as inside a Cohub sandbox; otherwise they are local files.
+Absolute paths outside /workspace are always local. Copies between Spaces
+run server-side; local files are uploaded or downloaded.
+
+Examples:
+  cohub spaces files cp -r alice/templates:starter ./starter
+  cohub spaces files cp report.pdf notes:inbox/
+  cohub -s <spaceId> spaces files cp -r other:docs docs
+  cohub spaces files cp /tmp/chart.png <spaceId>:assets/`)
+        .action((paths, opts) => copyFiles(spacesCmd, paths, opts));
+}

package/dist/commands/space-invitations.js

@@ -1,5 +1,6 @@
 import { buildSpaceInvitePath, } from "@neta-art/cohub";
 import { createClient } from "../client.js";
+import { webUrl } from "../web.js";
 import { error, handleHttp, json as outJson, jsonRequested, ok, table, } from "../output.js";
 import { resolveSpace } from "../space.js";
 const SPACE_ROLES = ["host", "builder", "guest"];
@@ -34,13 +35,12 @@ export function parseSpaceInvitationCreateOptions(options) {
     return { role, ttlSeconds: days * 24 * 60 * 60, maxUses };
 }
 function invitationUrl(invitation) {
-    const origin = process.env.COHUB_WEB_URL?.replace(/\/+$/, "") ?? "https://cohub.live";
-    return `${origin}${buildSpaceInvitePath({
+    return webUrl(buildSpaceInvitePath({
         spaceId: invitation.spaceId,
         ownerUsername: invitation.ownerUsername,
         spaceSlug: invitation.spaceSlug,
         inviteCode: invitation.token,
-    })}`;
+    }));
 }
 async function confirmRevoke(options) {
     if (options.yes)

package/dist/commands/spaces.d.ts

@@ -1,5 +1,6 @@
 import type { CohubHttpClient, CreateSpaceInput } from "@neta-art/cohub";
 import type { Command } from "commander";
+import { type LocalUploadEntry } from "../space-files/upload.js";
 export type SpaceCreateOptions = {
     name: string;
     description?: string;
@@ -9,20 +10,11 @@ export type SpaceCreateOptions = {
     spec?: string;
     json?: boolean;
 };
-type UploadFile = {
-    id: string;
-    localPath: string;
-    relativePath: string;
-    name: string;
-    size: number;
-    mimeType: string | null;
-};
 export declare function buildSpaceCreateInput(opts: SpaceCreateOptions): CreateSpaceInput;
-export declare const planUploadInput: (input: string) => Promise<UploadFile[]>;
-export declare function collectUploadFiles(paths: string[]): Promise<UploadFile[]>;
+export declare const planUploadInput: (input: string) => Promise<LocalUploadEntry[]>;
+export declare function collectUploadFiles(paths: string[]): Promise<LocalUploadEntry[]>;
 export declare function registerPrompt(program: Command): void;
 export declare function registerSpaceCreate(spacesCmd: Command, dependencies?: {
     createClient?: () => CohubHttpClient;
 }): Command;
 export declare function registerSpaces(program: Command): void;
-export {};