@neta-art/cohub-cli 6.6.0 → 6.8.0

package/dist/space.js

@@ -1,5 +1,85 @@
-import { error } from "./output.js";
-export function resolveSpace(program) {
+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 { readAuthSession } from "./auth.js";
+import { createClient } from "./client.js";
+import { error, handleHttp } from "./output.js";
+const CONFIG_DIR = join(homedir(), ".config", "cohub");
+const 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;
+function jwtClaim(token, key) {
+    const payload = token?.split(".")[1];
+    if (!payload)
+        return null;
+    try {
+        const parsed = JSON.parse(Buffer.from(payload, "base64url").toString("utf-8"));
+        const value = parsed[key];
+        return typeof value === "string" && value ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Cache key aligned with auth: execution token is exclusive (same as
+ * `resolveAccessToken`) and never falls back to a local Logto session.
+ * Execution grants identify the actor as `actorUserId`, not `sub`.
+ */
+export function identityKeyFrom(input) {
+    if (input.executionToken) {
+        const actor = jwtClaim(input.executionToken, "actorUserId") ?? jwtClaim(input.executionToken, "sub");
+        return actor ? `${input.env}:${actor}` : null;
+    }
+    const sub = jwtClaim(input.idToken, "sub") ?? jwtClaim(input.accessToken, "sub");
+    return sub ? `${input.env}:${sub}` : null;
+}
+function identityKey() {
+    const session = readAuthSession();
+    return identityKeyFrom({
+        env: resolveCohubEnvironment(),
+        executionToken: process.env.COHUB_EXECUTION_TOKEN?.trim(),
+        idToken: session?.idToken,
+        accessToken: session?.accessToken,
+    });
+}
+/** Exported for tests; production always uses `CACHE_PATH`. */
+export function readDefaultSpaceCache(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")
+            return null;
+        if (now - cache.cachedAt > CACHE_TTL_MS)
+            return null;
+        return cache.spaceId;
+    }
+    catch {
+        return null;
+    }
+}
+function writeCachedDefaultSpace(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 });
+    }
+    catch {
+        // Cache is best-effort; never fail the command over it.
+    }
+}
+let defaultSpacePromise = null;
+export function clearDefaultSpaceCache() {
+    defaultSpacePromise = null;
+    try {
+        rmSync(CACHE_PATH, { force: true });
+    }
+    catch {
+        // Best-effort, same as writes.
+    }
+}
+/** Explicit target from `-s/--space` (any ancestor) or `COHUB_SPACE_ID`, else null. */
+export function explicitSpace(program) {
     let current = program;
     while (current) {
         const opts = current.opts();
@@ -7,8 +87,39 @@ export function resolveSpace(program) {
             return opts.space.trim();
         current = current.parent ?? null;
     }
-    const envSpace = process.env.COHUB_SPACE_ID?.trim();
-    if (envSpace)
-        return envSpace;
-    return error("Missing required space", "Add -s, --space <id> or set COHUB_SPACE_ID.");
+    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 () => {
+        const key = identityKey();
+        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;
+    })();
+    return defaultSpacePromise;
+}
+/** 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.");
+}
+/**
+ * Target space for a command: explicit `-s`/`COHUB_SPACE_ID` first, then the
+ * user's home space. Exits with guidance when neither is available; request
+ * failures go through the shared HTTP error handler.
+ */
+export async function resolveSpace(program) {
+    return explicitSpace(program) ?? (await resolveDefaultSpace().catch(handleHttp)) ?? missingSpaceError();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "6.6.0",
+  "version": "6.8.0",
   "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.9.0"
+    "@neta-art/cohub": "8.10.1"
   },
   "publishConfig": {
     "access": "public"