@neta-art/cohub-cli 8.4.1 → 9.1.0

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 {};

package/dist/space-files/transfer.js

@@ -0,0 +1,296 @@
+import { randomUUID } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import { cp, lstat, mkdir, readdir, rename, rm, stat, utimes } from "node:fs/promises";
+import { dirname, join, posix } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { UPLOAD_MAX_FILE_BYTES } from "@neta-art/cohub";
+import { createLimiter } from "./limit.js";
+import { uploadLocalFiles } from "./upload.js";
+export class CopyAbortError extends Error {
+    name = "CopyAbortError";
+}
+export const emptyCopyResult = () => ({
+    files: 0, dirs: 0, symlinks: 0, bytes: 0, paths: [], overwritten: 0, skipped: 0, errors: [],
+});
+export function mergeCopyResults(results) {
+    const merged = emptyCopyResult();
+    for (const result of results) {
+        for (const key of ["files", "dirs", "symlinks", "bytes", "overwritten", "skipped"])
+            merged[key] += result[key];
+        merged.paths.push(...result.paths);
+        merged.errors.push(...result.errors);
+    }
+    return merged;
+}
+const display = (path) => path || ".";
+const targetOf = (source, destination, intoDirectory, join) => {
+    const name = posix.basename(source);
+    return intoDirectory && name ? join(destination, name) : destination;
+};
+const joinSpacePath = (parent, name) => (parent ? `${parent}/${name}` : name);
+const lstatOrNull = (path) => lstat(path).catch(() => null);
+export async function statSpacePath(files, path) {
+    try {
+        return { type: "dir", tree: await files.list(path) };
+    }
+    catch (error) {
+        const { status, code } = error;
+        if (status === 404)
+            return null;
+        if (code === "not_a_directory")
+            return { type: "file" };
+        throw error;
+    }
+}
+export async function checkDestination(input) {
+    const node = await input.stat(input.path);
+    if (input.sourceCount > 1 && node !== "dir")
+        throw new CopyAbortError(`target '${input.display}' is not a directory`);
+    if (!node && input.parent !== input.path && (await input.stat(input.parent)) !== "dir") {
+        throw new CopyAbortError(`cannot create '${input.display}': No such file or directory`);
+    }
+    return node === "dir";
+}
+export const spaceNodeType = async (files, path) => (await statSpacePath(files, path))?.type ?? null;
+export const localNodeType = async (path) => {
+    const stats = await lstatOrNull(path);
+    return stats ? (stats.isDirectory() ? "dir" : "file") : null;
+};
+const isUploadableName = (name) => name.length > 0 && name.length <= 255 && name !== "." && name !== ".." && name.trim() === name &&
+    !/[<>:"/\\|?*]/.test(name) && ![...name].some((char) => char.charCodeAt(0) <= 0x1f);
+export async function uploadToSpace(input) {
+    const { files, options } = input;
+    const result = emptyCopyResult();
+    const fail = (path, code, message) => {
+        result.errors.push({ path, code, message });
+    };
+    const entries = [];
+    const walk = async (localPath, target, stats) => {
+        if (stats.isFile()) {
+            entries.push({ localPath, relativePath: target, size: stats.size });
+            return;
+        }
+        if (!stats.isDirectory()) {
+            result.skipped += 1;
+            return;
+        }
+        const names = await readdir(localPath);
+        await Promise.all(names.map(async (name) => {
+            const child = join(localPath, name);
+            const childStats = await stat(child).catch(() => null);
+            if (childStats)
+                await walk(child, joinSpacePath(target, name), childStats);
+        }));
+    };
+    for (const source of input.sources) {
+        const stats = await stat(source).catch(() => null);
+        if (!stats) {
+            fail(source, "path_not_found", `cannot stat '${source}': No such file or directory`);
+            continue;
+        }
+        if (stats.isDirectory() && !options.recursive) {
+            fail(source, "is_a_directory", `-r not specified; omitting directory '${source}'`);
+            continue;
+        }
+        const target = targetOf(source, input.destination, input.intoDirectory, joinSpacePath);
+        await walk(source, target, stats);
+        result.paths.push(target);
+    }
+    const parents = [...new Set(entries.map((entry) => posix.dirname(entry.relativePath)).map((dir) => (dir === "." ? "" : dir)))];
+    const limit = createLimiter(8);
+    const existing = new Map();
+    await Promise.all(parents.map((dir) => limit(async () => {
+        const node = await statSpacePath(files, dir);
+        if (node?.type === "dir")
+            for (const entry of node.tree.entries)
+                existing.set(entry.path, entry.type);
+    })));
+    const upload = entries.filter((entry) => {
+        const current = existing.get(entry.relativePath);
+        if (current === "dir") {
+            fail(entry.relativePath, "is_a_directory", `cannot overwrite directory '${entry.relativePath}' with non-directory`);
+            return false;
+        }
+        if (current && options.noClobber) {
+            result.skipped += 1;
+            return false;
+        }
+        if (!entry.relativePath.split("/").every(isUploadableName)) {
+            fail(entry.relativePath, "name_invalid", `cannot upload '${entry.localPath}': unsupported file name`);
+            return false;
+        }
+        if (entry.size > UPLOAD_MAX_FILE_BYTES) {
+            fail(entry.relativePath, "file_too_large", `cannot upload '${entry.localPath}': file exceeds the upload size limit`);
+            return false;
+        }
+        if (current)
+            result.overwritten += 1;
+        return true;
+    });
+    const progress = { files: 0, dirs: 0, symlinks: 0, bytes: 0 };
+    await uploadLocalFiles(files, upload, {
+        onUploaded: (entry) => {
+            progress.files += 1;
+            progress.bytes += entry.size;
+            input.onProgress(progress);
+        },
+    });
+    return { ...result, ...progress };
+}
+export async function downloadFromSpace(input) {
+    const { options } = input;
+    const result = emptyCopyResult();
+    const fail = (path, code, message) => {
+        result.errors.push({ path, code, message });
+    };
+    const limit = createLimiter(6);
+    const report = () => input.onProgress(result);
+    const downloadFile = async (files, path, target, mtimeMs) => {
+        const current = await lstatOrNull(target);
+        if (current?.isDirectory())
+            return fail(target, "is_a_directory", `cannot overwrite directory '${target}' with non-directory`);
+        if (current && options.noClobber) {
+            result.skipped += 1;
+            return;
+        }
+        const temp = join(dirname(target), `.cohub-download.${randomUUID().slice(0, 8)}`);
+        try {
+            const bytes = await limit(async () => {
+                const { response } = await files.open(path);
+                let written = 0;
+                if (response.body) {
+                    const body = Readable.fromWeb(response.body);
+                    body.on("data", (chunk) => {
+                        written += chunk.length;
+                    });
+                    await pipeline(body, createWriteStream(temp, { flags: "wx" }));
+                }
+                else {
+                    await pipeline(Readable.from([]), createWriteStream(temp, { flags: "wx" }));
+                }
+                return written;
+            });
+            if (options.preserveTimestamps && mtimeMs !== undefined)
+                await utimes(temp, new Date(), new Date(mtimeMs));
+            await rename(temp, target);
+            result.files += 1;
+            result.bytes += bytes;
+            if (current)
+                result.overwritten += 1;
+            report();
+        }
+        catch (error) {
+            await rm(temp, { force: true });
+            fail(target, "download_failed", `cannot download '${display(path)}': ${error.message}`);
+        }
+    };
+    const downloadDir = async (files, tree, target) => {
+        const current = await lstatOrNull(target);
+        if (current && !current.isDirectory()) {
+            return fail(target, "not_a_directory", `cannot overwrite non-directory '${target}' with directory '${display(tree.path)}'`);
+        }
+        if (!current)
+            await mkdir(target);
+        result.dirs += 1;
+        if (tree.entries.length >= 1000) {
+            fail(target, "listing_truncated", `cannot copy all of '${display(tree.path)}': directories with 1000 or more entries are not fully listed`);
+        }
+        await Promise.all(tree.entries.map(async (entry) => {
+            const child = join(target, entry.name);
+            if (entry.type === "file")
+                return downloadFile(files, entry.path, child, entry.mtimeMs);
+            if (entry.type === "symlink") {
+                result.skipped += 1;
+                return;
+            }
+            const node = await limit(() => statSpacePath(files, entry.path));
+            if (node?.type === "dir")
+                await downloadDir(files, node.tree, child);
+        }));
+    };
+    for (const { files, path } of input.sources) {
+        const node = await statSpacePath(files, path);
+        if (!node) {
+            fail(path, "path_not_found", `cannot stat '${display(path)}': No such file or directory`);
+            continue;
+        }
+        if (node.type === "dir" && !options.recursive) {
+            fail(path, "is_a_directory", `-r not specified; omitting directory '${display(path)}'`);
+            continue;
+        }
+        const target = targetOf(path, input.destination, input.intoDirectory, join);
+        if (node.type === "dir") {
+            await downloadDir(files, node.tree, target);
+        }
+        else {
+            const parent = options.preserveTimestamps ? await statSpacePath(files, posix.dirname(path) === "." ? "" : posix.dirname(path)) : null;
+            const mtimeMs = parent?.type === "dir" ? parent.tree.entries.find((entry) => entry.path === path)?.mtimeMs : undefined;
+            await downloadFile(files, path, target, mtimeMs);
+        }
+        result.paths.push(target);
+    }
+    return result;
+}
+export async function copyLocal(input) {
+    const { options } = input;
+    const result = emptyCopyResult();
+    const fail = (path, code, message) => {
+        result.errors.push({ path, code, message });
+    };
+    for (const source of input.sources) {
+        const stats = await lstatOrNull(source);
+        if (!stats) {
+            fail(source, "path_not_found", `cannot stat '${source}': No such file or directory`);
+            continue;
+        }
+        if (stats.isDirectory() && !options.recursive) {
+            fail(source, "is_a_directory", `-r not specified; omitting directory '${source}'`);
+            continue;
+        }
+        const target = targetOf(source, input.destination, input.intoDirectory, join);
+        if (target === source) {
+            fail(source, "same_file", `'${source}' and '${target}' are the same file`);
+            continue;
+        }
+        if (stats.isDirectory() && target.startsWith(`${source}/`)) {
+            fail(source, "copy_into_itself", `cannot copy a directory, '${source}', into itself, '${target}'`);
+            continue;
+        }
+        try {
+            await cp(source, target, {
+                recursive: true,
+                force: !options.noClobber,
+                errorOnExist: false,
+                preserveTimestamps: options.preserveTimestamps,
+                verbatimSymlinks: true,
+                filter: async (from, to) => {
+                    const node = await lstat(from);
+                    if (node.isDirectory()) {
+                        result.dirs += 1;
+                        return true;
+                    }
+                    const existing = await lstatOrNull(to);
+                    if (existing && options.noClobber) {
+                        result.skipped += 1;
+                        return false;
+                    }
+                    if (existing)
+                        result.overwritten += 1;
+                    if (node.isSymbolicLink())
+                        result.symlinks += 1;
+                    else {
+                        result.files += 1;
+                        result.bytes += node.size;
+                    }
+                    return true;
+                },
+            });
+            result.paths.push(target);
+        }
+        catch (error) {
+            fail(target, "copy_failed", `cannot copy '${source}': ${error.message}`);
+        }
+    }
+    return result;
+}

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

@@ -0,0 +1,14 @@
+import { type CohubHttpClient, type SpaceFsUploadEntry } from "@neta-art/cohub";
+export type SpaceFiles = ReturnType<CohubHttpClient["space"]>["files"];
+export type LocalUploadEntry = {
+    localPath: string;
+    relativePath: string;
+    size: number;
+};
+export declare function uploadLocalFiles(files: SpaceFiles, entries: LocalUploadEntry[], options?: {
+    targetDir?: string;
+    onUploaded?: (entry: LocalUploadEntry) => void;
+}): Promise<{
+    uploaded: SpaceFsUploadEntry[];
+    uploadIds: string[];
+}>;

package/dist/space-files/upload.js

@@ -0,0 +1,53 @@
+import { randomUUID } from "node:crypto";
+import { UPLOAD_MAX_BATCH_BYTES, UPLOAD_MAX_BATCH_FILES, } from "@neta-art/cohub";
+import { putLocalFile } from "../http-put.js";
+import { createLimiter } from "./limit.js";
+const PUT_CONCURRENCY = 4;
+function batches(entries) {
+    const result = [];
+    let batch = [];
+    let bytes = 0;
+    for (const entry of entries) {
+        if (batch.length > 0 && (batch.length >= UPLOAD_MAX_BATCH_FILES || bytes + entry.size > UPLOAD_MAX_BATCH_BYTES)) {
+            result.push(batch);
+            batch = [];
+            bytes = 0;
+        }
+        batch.push(entry);
+        bytes += entry.size;
+    }
+    if (batch.length > 0)
+        result.push(batch);
+    return result;
+}
+export async function uploadLocalFiles(files, entries, options = {}) {
+    const uploaded = [];
+    const uploadIds = [];
+    const limit = createLimiter(PUT_CONCURRENCY);
+    for (const batch of batches(entries)) {
+        const byId = new Map(batch.map((entry) => [randomUUID(), entry]));
+        const plan = await files.createUpload({
+            destination: { kind: "workspace", targetDir: options.targetDir },
+            entries: [...byId].map(([id, entry]) => ({
+                id,
+                name: entry.relativePath.split("/").at(-1) ?? entry.relativePath,
+                relativePath: entry.relativePath,
+                size: entry.size,
+                mimeType: null,
+            })),
+        });
+        await Promise.all(plan.entries.map((item) => limit(async () => {
+            const entry = byId.get(item.id);
+            if (!entry)
+                throw new Error(`Missing upload entry: ${item.id}`);
+            if (item.uploadUrl) {
+                await putLocalFile({ url: item.uploadUrl, filePath: entry.localPath, size: entry.size, headers: item.headers, label: entry.relativePath });
+            }
+            options.onUploaded?.(entry);
+        })));
+        const result = await files.completeUpload(plan.uploadId, { entries: plan.entries.map((item) => ({ id: item.id })) });
+        uploaded.push(...result.uploaded);
+        uploadIds.push(plan.uploadId);
+    }
+    return { uploaded, uploadIds };
+}

package/dist/space.d.ts

@@ -1,4 +1,9 @@
 import type { Command } from "commander";
+export declare class SpaceTargetError extends Error {
+    readonly detail?: string | undefined;
+    name: string;
+    constructor(message: string, detail?: string | undefined);
+}
 /**
  * Cache key aligned with auth: execution token is exclusive (same as
  * `resolveAccessToken`) and never falls back to a local Logto session.
@@ -12,29 +17,26 @@ export declare function identityKeyFrom(input: {
 }): string | null;
 export declare function currentIdentityKey(): string | null;
 /** Exported for tests; production always uses `CACHE_PATH`. */
-export declare function readDefaultSpaceCache(path: string, key: string, now?: number): string | null;
-export declare function clearDefaultSpaceCache(): void;
+export declare function readHomeSpaceCache(path: string, key: string, now?: number): string | null;
+export declare function clearHomeSpaceCache(): void;
 /** Explicit target from `-s/--space` (any ancestor) or `COHUB_SPACE_ID`, else null. */
 export declare function explicitSpace(program: Command): string | null;
-/**
- * Resolve the user's home space when no target is given. Cached locally per
- * identity so repeated invocations skip the network entirely, and memoized
- * in-process so preAction hooks and actions share a single lookup.
- * Network and auth failures propagate so callers can report them faithfully.
- */
-export declare function resolveDefaultSpace(): Promise<string | null>;
+/** Cached per identity and memoized per process. */
+export declare function resolveHomeSpace(): Promise<string>;
+export declare function resolveSpaceRef(value: string): Promise<string>;
+export declare function failSpaceTarget(e: unknown): never;
 /** Shared exit for commands that need a space but resolved none. */
 export declare function missingSpaceError(): never;
-/**
- * Resolve a Space from an optional explicit target, the current directory
- * binding, and finally the user's Home Space.
- */
 export declare function resolveBoundSpace(options?: {
     cwd?: string;
     bindingsPath?: string;
 }): Promise<string | null>;
-export declare function resolveSpaceTarget(target?: string | null, options?: {
+export type SpaceTargetOptions = {
+    /** Only for commands that start new work. */
+    home?: boolean;
     cwd?: string;
     bindingsPath?: string;
-}): Promise<string>;
-export declare function resolveSpace(program: Command): Promise<string>;
+};
+/** Explicit target or `COHUB_SPACE_ID`, then the directory binding, then Home when allowed. */
+export declare function resolveSpaceTarget(target?: string | null, options?: SpaceTargetOptions): Promise<string>;
+export declare function resolveSpace(command: Command, options?: Pick<SpaceTargetOptions, "home">): Promise<string>;

package/dist/space.js

@@ -1,15 +1,26 @@
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { resolveCohubEnvironment } from "@neta-art/cohub";
+import { HOME_SPACE_SLUG, parseSpaceRef, resolveCohubEnvironment } from "@neta-art/cohub";
 import { readAuthSession } from "./auth.js";
 import { createClient } from "./client.js";
 import { getRuntimeSpaceBinding } from "./runtime/space-binding.js";
 import { error, handleHttp } from "./output.js";
 const CONFIG_DIR = join(homedir(), ".config", "cohub");
-const CACHE_PATH = join(CONFIG_DIR, "default-space.json");
+const CACHE_PATH = join(CONFIG_DIR, "home-space.json");
+/** Legacy cache that may name another user's Home; never read. */
+const LEGACY_CACHE_PATH = join(CONFIG_DIR, "default-space.json");
 /** Home space is stable; a one-day TTL bounds how long a stale hit survives. */
 const CACHE_TTL_MS = 86_400_000;
+const SPACE_REF_HINT = "Use a Space ID, a slug you own such as home, or username/slug.";
+export class SpaceTargetError extends Error {
+    detail;
+    name = "SpaceTargetError";
+    constructor(message, detail) {
+        super(message);
+        this.detail = detail;
+    }
+}
 function jwtClaim(token, key) {
     const payload = token?.split(".")[1];
     if (!payload)
@@ -46,7 +57,7 @@ export function currentIdentityKey() {
     });
 }
 /** Exported for tests; production always uses `CACHE_PATH`. */
-export function readDefaultSpaceCache(path, key, now = Date.now()) {
+export function readHomeSpaceCache(path, key, now = Date.now()) {
     try {
         const cache = JSON.parse(readFileSync(path, "utf-8"));
         if (cache.key !== key || typeof cache.spaceId !== "string" || typeof cache.cachedAt !== "number")
@@ -59,21 +70,25 @@ export function readDefaultSpaceCache(path, key, now = Date.now()) {
         return null;
     }
 }
-function writeCachedDefaultSpace(key, spaceId) {
+function writeHomeSpaceCache(key, spaceId) {
     try {
         mkdirSync(CONFIG_DIR, { recursive: true });
         const cache = { key, spaceId, cachedAt: Date.now() };
         writeFileSync(CACHE_PATH, `${JSON.stringify(cache, null, 2)}\n`, { encoding: "utf-8", mode: 0o600 });
+        rmSync(LEGACY_CACHE_PATH, { force: true });
     }
     catch {
         // Cache is best-effort; never fail the command over it.
     }
 }
-let defaultSpacePromise = null;
-export function clearDefaultSpaceCache() {
-    defaultSpacePromise = null;
+let homeSpacePromise = null;
+const spaceRefs = new Map();
+export function clearHomeSpaceCache() {
+    homeSpacePromise = null;
+    spaceRefs.clear();
     try {
         rmSync(CACHE_PATH, { force: true });
+        rmSync(LEGACY_CACHE_PATH, { force: true });
     }
     catch {
         // Best-effort, same as writes.
@@ -90,48 +105,80 @@ export function explicitSpace(program) {
     }
     return process.env.COHUB_SPACE_ID?.trim() || null;
 }
-/**
- * Resolve the user's home space when no target is given. Cached locally per
- * identity so repeated invocations skip the network entirely, and memoized
- * in-process so preAction hooks and actions share a single lookup.
- * Network and auth failures propagate so callers can report them faithfully.
- */
-export function resolveDefaultSpace() {
-    defaultSpacePromise ??= (async () => {
+/** Cached per identity and memoized per process. */
+export function resolveHomeSpace() {
+    homeSpacePromise ??= (async () => {
         const key = currentIdentityKey();
-        if (key) {
-            const cached = readDefaultSpaceCache(CACHE_PATH, key);
-            if (cached)
-                return cached;
-        }
-        const space = (await createClient().spaces.getDefault()).space ?? null;
-        // Recent-space fallback from getDefault() is not stable enough to cache.
-        if (space?.id && space.slug === "home" && key)
-            writeCachedDefaultSpace(key, space.id);
-        return space?.id ?? null;
+        const cached = key ? readHomeSpaceCache(CACHE_PATH, key) : null;
+        if (cached)
+            return cached;
+        const space = await createClient().spaces.ensureHome();
+        if (key)
+            writeHomeSpaceCache(key, space.id);
+        return space.id;
     })();
-    return defaultSpacePromise;
+    return homeSpacePromise;
+}
+async function lookupSpaceRef(value) {
+    const ref = parseSpaceRef(value);
+    if (!ref)
+        throw new SpaceTargetError(`Invalid space '${value}'`, SPACE_REF_HINT);
+    if (ref.kind === "id")
+        return ref.id;
+    if (ref.kind === "owned" && ref.slug === HOME_SPACE_SLUG)
+        return resolveHomeSpace();
+    const spaces = createClient().spaces;
+    try {
+        const space = ref.kind === "owned"
+            ? await spaces.getOwnedBySlug(ref.slug)
+            : await spaces.getBySlug(ref.username, ref.slug);
+        return space.id;
+    }
+    catch (e) {
+        if (e.status === 404)
+            throw new SpaceTargetError(`Space '${value}' not found`, SPACE_REF_HINT);
+        throw e;
+    }
+}
+export function resolveSpaceRef(value) {
+    const key = value.trim();
+    let resolved = spaceRefs.get(key);
+    if (!resolved) {
+        resolved = lookupSpaceRef(key);
+        spaceRefs.set(key, resolved);
+    }
+    return resolved;
+}
+export function failSpaceTarget(e) {
+    if (e instanceof SpaceTargetError)
+        return error(e.message, e.detail);
+    return handleHttp(e);
 }
 /** Shared exit for commands that need a space but resolved none. */
 export function missingSpaceError() {
-    return error("No target space", "Add -s, --space <id> or set COHUB_SPACE_ID. Run `cohub auth login` to use your home space.");
+    return error("No target space", "Pass -s <space> (an ID, home, or username/slug), set COHUB_SPACE_ID, or run in a directory bound with `cohub runtime up`.");
 }
-/**
- * Resolve a Space from an optional explicit target, the current directory
- * binding, and finally the user's Home Space.
- */
 export async function resolveBoundSpace(options = {}) {
     const bound = await getRuntimeSpaceBinding(options.cwd ?? process.cwd(), currentIdentityKey(), options.bindingsPath).catch(handleHttp);
     return bound?.spaceId ?? null;
 }
+/** Explicit target or `COHUB_SPACE_ID`, then the directory binding, then Home when allowed. */
 export async function resolveSpaceTarget(target, options = {}) {
     const explicit = target?.trim() || process.env.COHUB_SPACE_ID?.trim() || null;
-    if (explicit)
-        return explicit;
-    return (await resolveBoundSpace(options))
-        ?? (await resolveDefaultSpace().catch(handleHttp))
-        ?? missingSpaceError();
-}
-export async function resolveSpace(program) {
-    return resolveSpaceTarget(explicitSpace(program));
+    try {
+        if (explicit)
+            return await resolveSpaceRef(explicit);
+        const bound = await resolveBoundSpace(options);
+        if (bound)
+            return bound;
+        if (options.home)
+            return await resolveHomeSpace();
+    }
+    catch (e) {
+        return failSpaceTarget(e);
+    }
+    return missingSpaceError();
+}
+export function resolveSpace(command, options = {}) {
+    return resolveSpaceTarget(explicitSpace(command), options);
 }

package/dist/web.d.ts

@@ -0,0 +1 @@
+export declare function webUrl(path: string): string;

package/dist/web.js

@@ -0,0 +1,6 @@
+import { resolveCohubEnvironment } from "@neta-art/cohub";
+export function webUrl(path) {
+    const origin = process.env.COHUB_WEB_URL?.replace(/\/+$/, "") ??
+        `https://${resolveCohubEnvironment() === "prod" ? "" : "dev."}cohub.live`;
+    return `${origin}${path}`;
+}