@zalify/cli 0.2.4 → 0.4.0

package/dist/cli.js

@@ -11308,11 +11308,36 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 var dir = join(homedir(), ".zalify");
 var file = join(dir, "config.json");
+function migrate(raw) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const obj = raw;
+  if (obj.version === 3 && obj.userKey && obj.appUrl)
+    return obj;
+  if (obj.version === 2 && obj.workspaces && obj.appUrl)
+    return obj;
+  if (typeof obj.key === "string" && typeof obj.workspaceId === "string") {
+    return {
+      version: 2,
+      appUrl: obj.appUrl ?? "https://app.zalify.com",
+      activeWorkspaceId: obj.workspaceId,
+      workspaces: {
+        [obj.workspaceId]: {
+          key: obj.key,
+          name: obj.workspaceName ?? "",
+          slug: obj.workspaceSlug ?? "",
+          createdAt: obj.createdAt ?? new Date().toISOString()
+        }
+      }
+    };
+  }
+  return null;
+}
 function readConfig() {
   if (!existsSync(file))
     return null;
   try {
-    return JSON.parse(readFileSync(file, "utf8"));
+    return migrate(JSON.parse(readFileSync(file, "utf8")));
   } catch {
     return null;
   }
@@ -11325,12 +11350,38 @@ function writeConfig(config) {
 function deleteConfig() {
   rmSync(file, { force: true });
 }
-function requireConfig() {
+function requireActive() {
   const config = readConfig();
-  if (!config?.key) {
+  if (!config) {
     throw new Error("Not logged in. Run `zalify login` first.");
   }
-  return config;
+  if (config.version === 3) {
+    if (!config.active) {
+      throw new Error("No active workspace. Run `zalify workspace list` then `zalify workspace set <slug>`.");
+    }
+    return {
+      appUrl: config.appUrl,
+      key: config.userKey,
+      workspaceId: config.active.id,
+      workspaceName: config.active.name,
+      workspaceSlug: config.active.slug,
+      config
+    };
+  }
+  const ids = Object.keys(config.workspaces);
+  if (ids.length === 0) {
+    throw new Error("Not logged in. Run `zalify login` first.");
+  }
+  const workspaceId = config.activeWorkspaceId && config.workspaces[config.activeWorkspaceId] ? config.activeWorkspaceId : ids[0];
+  const entry = config.workspaces[workspaceId];
+  return {
+    appUrl: config.appUrl,
+    key: entry.key,
+    workspaceId,
+    workspaceName: entry.name,
+    workspaceSlug: entry.slug,
+    config
+  };
 }
 
 // src/auth.ts
@@ -11346,10 +11397,26 @@ function openBrowser(url) {
     detached: true
   }).unref();
 }
+function decodePayload(encoded) {
+  const b64 = encoded.replace(/-/g, "+").replace(/_/g, "/");
+  return JSON.parse(Buffer.from(b64, "base64").toString("utf8"));
+}
+async function fetchWorkspaces(appUrl, userKey) {
+  try {
+    const res = await fetch(`${appUrl}/api/cli/workspaces`, {
+      headers: { Authorization: `Bearer ${userKey}` }
+    });
+    if (!res.ok)
+      return [];
+    return (await res.json()).workspaces;
+  } catch {
+    return [];
+  }
+}
 async function login(options) {
   const base = (options.appUrl || readConfig()?.appUrl || DEFAULT_APP_URL).replace(/\/$/, "");
   const state = randomBytes(32).toString("hex");
-  const result = await new Promise((resolvePromise, reject) => {
+  const payload = await new Promise((resolvePromise, reject) => {
     const timer = setTimeout(() => {
       server.close();
       server.closeAllConnections();
@@ -11387,22 +11454,38 @@ async function login(options) {
         });
         return;
       }
-      const key = url.searchParams.get("key");
-      if (!key) {
-        done("Login failed: no key in callback.", () => {
+      const encoded = url.searchParams.get("payload");
+      const legacyKey = url.searchParams.get("key");
+      let parsed = null;
+      if (encoded) {
+        try {
+          parsed = decodePayload(encoded);
+        } catch {
+          parsed = null;
+        }
+      } else if (legacyKey) {
+        parsed = {
+          keys: [
+            {
+              workspaceId: url.searchParams.get("workspace_id") ?? "",
+              workspaceName: url.searchParams.get("workspace_name") ?? "",
+              workspaceSlug: url.searchParams.get("workspace_slug") ?? "",
+              key: legacyKey
+            }
+          ]
+        };
+      }
+      if (!parsed || !parsed.userKey && !parsed.keys?.length) {
+        done("Login failed: no credentials in callback.", () => {
           teardown();
-          reject(new Error("Callback did not include a key."));
+          reject(new Error("Callback did not include credentials."));
         });
         return;
       }
+      const result = parsed;
       done("Logged in!", () => {
         teardown();
-        resolvePromise({
-          key,
-          workspaceId: url.searchParams.get("workspace_id") ?? "",
-          workspaceName: url.searchParams.get("workspace_name") ?? "",
-          workspaceSlug: url.searchParams.get("workspace_slug") ?? ""
-        });
+        resolvePromise(result);
       });
     });
     server.listen(0, "127.0.0.1", () => {
@@ -11416,13 +11499,57 @@ async function login(options) {
     });
     server.on("error", reject);
   });
-  writeConfig({ appUrl: base, ...result, createdAt: new Date().toISOString() });
-  console.log(`✓ Logged in to workspace "${result.workspaceName || result.workspaceId}" (key stored in ~/.zalify/config.json)`);
+  if (payload.userKey && payload.user) {
+    const previous = readConfig();
+    const previousActive = previous?.version === 3 ? previous.active : previous?.version === 2 && previous.activeWorkspaceId ? {
+      id: previous.activeWorkspaceId,
+      name: previous.workspaces[previous.activeWorkspaceId]?.name ?? "",
+      slug: previous.workspaces[previous.activeWorkspaceId]?.slug ?? ""
+    } : null;
+    const workspaces = await fetchWorkspaces(base, payload.userKey);
+    const active = previousActive && workspaces.find((w) => w.id === previousActive.id) || workspaces[0] || previousActive || null;
+    writeConfig({
+      version: 3,
+      appUrl: base,
+      userKey: payload.userKey,
+      user: payload.user,
+      active,
+      workspacesCache: workspaces
+    });
+    console.log(`✓ Logged in as ${payload.user.name ?? payload.user.email ?? payload.user.id} — key covers ${workspaces.length || "your"} workspace(s), expires in 90 days.`);
+    if (active)
+      console.log(`  Active workspace: ${active.name} (${active.slug})`);
+    console.log("  Switch with `zalify workspace set <slug>`.");
+    return;
+  }
+  const existing = readConfig();
+  const config = {
+    version: 2,
+    appUrl: base,
+    activeWorkspaceId: existing?.version === 2 ? existing.activeWorkspaceId : null,
+    workspaces: {
+      ...existing?.version === 2 && existing.appUrl === base ? existing.workspaces : {}
+    }
+  };
+  const now = new Date().toISOString();
+  for (const k of payload.keys ?? []) {
+    config.workspaces[k.workspaceId] = {
+      key: k.key,
+      name: k.workspaceName,
+      slug: k.workspaceSlug,
+      createdAt: now
+    };
+  }
+  if (!config.activeWorkspaceId || !config.workspaces[config.activeWorkspaceId]) {
+    config.activeWorkspaceId = payload.keys?.[0]?.workspaceId ?? null;
+  }
+  writeConfig(config);
+  console.log(`✓ Authorized ${payload.keys?.length ?? 0} workspace(s) (legacy keys).`);
 }
 function logout() {
   deleteConfig();
   console.log("✓ Logged out (local credentials deleted).");
-  console.log("  To revoke the key itself: app.zalify.com → Settings → Developer.");
+  console.log("  CLI keys expire after 90 days; revoke sooner via app.zalify.com if needed.");
 }
 function ago(iso) {
   if (!iso)
@@ -11439,17 +11566,15 @@ function ago(iso) {
   return `${Math.round(hours / 24)}d ago`;
 }
 async function whoami() {
-  const config = requireConfig();
+  const auth = requireActive();
   let live = null;
   let liveError = null;
   try {
-    const res = await fetch(`${config.appUrl}/api/cli/whoami`, {
-      headers: { Authorization: `Bearer ${config.key}` }
-    });
+    const res = await fetch(`${auth.appUrl}/api/cli/whoami?workspaceId=${encodeURIComponent(auth.workspaceId)}`, { headers: { Authorization: `Bearer ${auth.key}` } });
     if (res.ok) {
       live = await res.json();
     } else if (res.status === 401) {
-      liveError = "key is invalid or was revoked — run `zalify login`";
+      liveError = "key is invalid, expired, or revoked — run `zalify login`";
     } else {
       liveError = `server returned ${res.status}`;
     }
@@ -11457,18 +11582,21 @@ async function whoami() {
     liveError = "could not reach the server (offline?)";
   }
   const ws = live?.workspace;
-  console.log(`workspace  ${ws?.name ?? config.workspaceName ?? "(unknown)"} (${ws?.slug ?? config.workspaceSlug ?? "?"}) [${ws?.id ?? config.workspaceId}]`);
+  const keyKind = auth.key.startsWith("zalify_cli_") ? "user key" : "workspace key";
+  console.log(`workspace  ${ws?.name ?? auth.workspaceName ?? "(unknown)"} (${ws?.slug ?? auth.workspaceSlug ?? "?"}) [${ws?.id ?? auth.workspaceId}]`);
+  if (auth.config.version === 3) {
+    console.log(`user       ${auth.config.user.name ?? auth.config.user.email ?? auth.config.user.id}`);
+  } else if (live?.key.createdByName) {
+    console.log(`user       ${live.key.createdByName}`);
+  }
   if (live) {
     console.log(`plan       ${live.plan.name} (${live.plan.type})`);
-    if (live.key.createdByName) {
-      console.log(`user       ${live.key.createdByName}`);
-    }
-    console.log(`key        ${live.key.name ?? config.key.slice(0, 16) + "…"} — created ${live.key.createdAt ? new Date(live.key.createdAt).toISOString().slice(0, 10) : "?"}, last used ${ago(live.key.lastRequest)}`);
+    console.log(`key        ${live.key.name ?? auth.key.slice(0, 16) + "…"} (${keyKind}) — created ${live.key.createdAt ? new Date(live.key.createdAt).toISOString().slice(0, 10) : "?"}, last used ${ago(live.key.lastRequest)}`);
   } else {
-    console.log(`key        ${config.key.slice(0, 16)}…`);
+    console.log(`key        ${auth.key.slice(0, 16)}… (${keyKind})`);
   }
-  const slug = ws?.slug ?? config.workspaceSlug;
-  console.log(`app        ${slug ? `${config.appUrl}/store/${slug}` : config.appUrl}`);
+  const slug = ws?.slug ?? auth.workspaceSlug;
+  console.log(`app        ${slug ? `${auth.appUrl}/store/${slug}` : auth.appUrl}`);
   console.log(live ? "status     ✓ key verified" : `status     ! not verified — ${liveError}`);
 }
 
@@ -11513,23 +11641,23 @@ async function assetsPull(storeDir) {
   console.log(`Done: ${pulled} downloaded, ${Object.keys(index).length - pulled} already local.`);
 }
 async function assetsPush(storeDir) {
-  const config = requireConfig();
+  const { appUrl, workspaceId, key, workspaceName, workspaceSlug } = requireActive();
   const imagesDir = imagesDirFor(storeDir);
   const indexPath = join2(imagesDir, "assets.json");
   const index = readIndex(imagesDir);
   async function api(path9, body) {
-    const res = await fetch(`${config.appUrl}${path9}`, {
+    const res = await fetch(`${appUrl}${path9}`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${config.key}`
+        Authorization: `Bearer ${key}`
       },
       body: JSON.stringify(body)
     });
     const json = await res.json().catch(() => ({}));
     if (!res.ok) {
       if (json.code === "UPGRADE_REQUIRED") {
-        const billingUrl = config.workspaceSlug ? `${config.appUrl}/store/${config.workspaceSlug}/settings/billing` : `${config.appUrl} (Settings → Billing)`;
+        const billingUrl = workspaceSlug ? `${appUrl}/store/${workspaceSlug}/settings/billing` : `${appUrl} (Settings → Billing)`;
         throw new Error(`${json.error ?? "This feature requires a paid plan."}
 ` + `  Upgrade this workspace: ${billingUrl}`);
       }
@@ -11545,11 +11673,11 @@ async function assetsPush(storeDir) {
     console.log("Everything already pushed.");
     return;
   }
-  console.log(`Pushing ${files.length} file(s) to "${config.workspaceName || config.workspaceId}"`);
+  console.log(`Pushing ${files.length} file(s) to "${workspaceName || workspaceId}"`);
   for (let i = 0;i < files.length; i += BATCH) {
     const batch = files.slice(i, i + BATCH);
     const { uploads } = await api("/api/assets/presign", {
-      workspaceId: config.workspaceId,
+      workspaceId,
       folderId: process.env.ZALIFY_FOLDER_ID ?? null,
       files: batch.map((f) => ({
         id: f.name,
@@ -11589,7 +11717,7 @@ async function assetsPush(storeDir) {
     }
     if (toFinalize.length) {
       const { assets, pending } = await api("/api/assets/finalize", {
-        workspaceId: config.workspaceId,
+        workspaceId,
         items: toFinalize.map(({ file: file2, up }) => ({
           assetId: up.assetId,
           checksum: file2.checksum,
@@ -11648,6 +11776,77 @@ Try manually: ${cmd} ${args.join(" ")}`);
 ✓ Done${updated ? ` (version: ${updated})` : ""}`);
 }
 
+// src/workspace.ts
+async function fetchWorkspaces2(appUrl, userKey) {
+  try {
+    const res = await fetch(`${appUrl}/api/cli/workspaces`, {
+      headers: { Authorization: `Bearer ${userKey}` }
+    });
+    if (!res.ok)
+      return null;
+    const json = await res.json();
+    return json.workspaces;
+  } catch {
+    return null;
+  }
+}
+async function workspaceList() {
+  const config = readConfig();
+  if (!config)
+    throw new Error("Not logged in. Run `zalify login` first.");
+  if (config.version === 3) {
+    const live = await fetchWorkspaces2(config.appUrl, config.userKey);
+    const list = live ?? config.workspacesCache;
+    if (live) {
+      config.workspacesCache = live;
+      writeConfig(config);
+    } else {
+      console.log(`! could not fetch live list — showing cached workspaces
+`);
+    }
+    for (const w of list) {
+      const marker = w.id === config.active?.id ? "* " : "  ";
+      console.log(`${marker}${w.slug.padEnd(36)} ${w.name} [${w.id}]`);
+    }
+    return;
+  }
+  const entries = Object.entries(config.workspaces);
+  if (entries.length === 0)
+    throw new Error("Not logged in. Run `zalify login` first.");
+  for (const [id, w] of entries) {
+    const marker = id === config.activeWorkspaceId ? "* " : "  ";
+    console.log(`${marker}${w.slug.padEnd(36)} ${w.name} [${id}]`);
+  }
+}
+async function workspaceSet(slugOrId) {
+  const config = readConfig();
+  if (!config)
+    throw new Error("Not logged in. Run `zalify login` first.");
+  if (config.version === 3) {
+    const live = await fetchWorkspaces2(config.appUrl, config.userKey);
+    const list = live ?? config.workspacesCache;
+    if (live)
+      config.workspacesCache = live;
+    const match = list.find((w) => w.id === slugOrId || w.slug === slugOrId || w.name === slugOrId);
+    if (!match) {
+      throw new Error(`No workspace matches "${slugOrId}". Known: ${list.map((w) => w.slug).join(", ")}.`);
+    }
+    config.active = match;
+    writeConfig(config);
+    console.log(`✓ Active workspace: ${match.name} (${match.slug})`);
+    return;
+  }
+  const found = Object.entries(config.workspaces).find(([id, w]) => id === slugOrId || w.slug === slugOrId || w.name === slugOrId);
+  if (!found) {
+    const known = Object.values(config.workspaces).map((w) => w.slug).join(", ");
+    throw new Error(`No authorized workspace matches "${slugOrId}". Known: ${known}.
+` + "Run `zalify login` to authorize more workspaces.");
+  }
+  config.activeWorkspaceId = found[0];
+  writeConfig(config);
+  console.log(`✓ Active workspace: ${found[1].name} (${found[1].slug})`);
+}
+
 // src/cli.ts
 var __dirname4 = dirname(fileURLToPath3(import.meta.url));
 var require2 = createRequire2(import.meta.url);
@@ -11688,6 +11887,13 @@ program2.command("logout").description("Delete the stored CLI credentials").acti
 program2.command("whoami").description("Verify the stored key and show workspace, plan, and key details").action(async () => {
   await whoami();
 });
+var workspace = program2.command("workspace").description("List authorized workspaces or switch the active one");
+workspace.command("list", { isDefault: true }).description("List authorized workspaces (* = active)").action(async () => {
+  await workspaceList();
+});
+workspace.command("set <slug-or-id>").description("Switch the active workspace (local, no re-login)").action(async (slugOrId) => {
+  await workspaceSet(slugOrId);
+});
 var assets = program2.command("assets").description("Sync images with the Zalify asset library");
 assets.command("push <store-dir>").description("Upload <store-dir>/images/*.png (sha256 dedup, writes assets.json)").action(async (storeDir) => {
   await assetsPush(storeDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zalify/cli",
-  "version": "0.2.4",
+  "version": "0.4.0",
   "description": "Zalify CLI - command-line interface for Zalify",
   "type": "module",
   "main": "dist/cli.js",