@alook/cli 0.0.121 → 0.0.122

package/dist/index.js

@@ -16986,6 +16986,7 @@ function loadCLIConfigForProfile(profile) {
   }
   const result = {
     server_url: cfg.server_url || "",
+    session_token: cfg.session_token,
     watched_workspaces: cfg.watched_workspaces || []
   };
   const legacy = cfg.machine_token;
@@ -17010,6 +17011,7 @@ function saveCLIConfigForProfile(profile, profileConfig) {
     cfg.profiles[profile] = profileConfig;
   } else {
     cfg.server_url = profileConfig.server_url;
+    cfg.session_token = profileConfig.session_token;
     cfg.watched_workspaces = profileConfig.watched_workspaces;
     delete cfg.machine_token;
   }
@@ -17429,6 +17431,30 @@ function openBrowser(url2) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function syncWorkspacesToConfig(serverWorkspaces, profile, sessionToken) {
+  const cfg = loadCLIConfigForProfile(profile);
+  const watched = cfg.watched_workspaces || [];
+  const serverIds = new Set(serverWorkspaces.map((w) => w.id));
+  for (const sw of serverWorkspaces) {
+    const existing = watched.find((w) => w.id === sw.id);
+    if (existing) {
+      existing.status = "active";
+      existing.name = sw.name;
+    } else {
+      watched.push({ id: sw.id, name: sw.name, token: "", status: "active", agent_ids: [] });
+    }
+  }
+  for (const w of watched) {
+    if (w.id && !serverIds.has(w.id) && w.status !== "registered") {
+      w.status = "deleted";
+    }
+  }
+  saveCLIConfigForProfile(profile, {
+    server_url: cfg.server_url,
+    session_token: sessionToken ?? cfg.session_token,
+    watched_workspaces: watched
+  });
+}
 async function pollAndActivate(opts) {
   const { deviceCode, expiresIn, serverUrl, profile } = opts;
   let interval = opts.interval;
@@ -17479,13 +17505,12 @@ async function pollAndActivate(opts) {
     const me = await client.getJSON("/api/me");
     email3 = me.email;
   } catch {}
-  let existingWorkspaceId = "";
+  let serverWorkspaces = [];
   try {
-    const workspaces = await client.getJSON("/api/workspaces");
-    if (workspaces.length > 0) {
-      existingWorkspaceId = workspaces[0].id;
-    }
+    serverWorkspaces = await client.getJSON("/api/workspaces");
   } catch {}
+  syncWorkspacesToConfig(serverWorkspaces, profile, sessionToken);
+  const existingWorkspaceId = serverWorkspaces.length > 0 ? serverWorkspaces[0].id : "";
   const mtUrl = existingWorkspaceId ? `/api/machine-tokens?workspace_id=${existingWorkspaceId}` : "/api/machine-tokens";
   let machineToken2;
   try {
@@ -17515,32 +17540,37 @@ if (process.argv.includes("--__login-poll")) {
 }
 async function checkExistingAuth(serverUrl, profile) {
   const config2 = loadCLIConfigForProfile(profile);
+  const sessionToken = config2.session_token;
   const workspaces = config2.watched_workspaces || [];
-  if (workspaces.length === 0) {
-    return { valid: false };
-  }
   const ws = workspaces[0];
-  if (!ws.token) {
+  const authToken = sessionToken || ws?.token;
+  if (!authToken) {
     return { valid: false };
   }
   try {
     const res = await fetch(`${serverUrl}/api/workspaces`, {
-      headers: { Authorization: `Bearer ${ws.token}` }
+      headers: { Authorization: `Bearer ${authToken}` }
     });
     if (!res.ok) {
       return { valid: false };
     }
+    const serverWorkspaces = await res.json();
+    const hasValidWorkspace = workspaces.some((w) => w.id && w.status !== "deleted");
+    if (!hasValidWorkspace && serverWorkspaces.length > 0) {
+      syncWorkspacesToConfig(serverWorkspaces, profile);
+    }
     let email3;
     try {
       const meRes = await fetch(`${serverUrl}/api/me`, {
-        headers: { Authorization: `Bearer ${ws.token}` }
+        headers: { Authorization: `Bearer ${authToken}` }
       });
       if (meRes.ok) {
         const me = await meRes.json();
         email3 = me.email;
       }
     } catch {}
-    return { valid: true, email: email3, workspaceName: ws.name ?? undefined };
+    const workspaceName = (serverWorkspaces.length > 0 ? serverWorkspaces[0].name : undefined) || ws?.name || undefined;
+    return { valid: true, email: email3, workspaceName };
   } catch {
     return { valid: false };
   }
@@ -22175,6 +22205,14 @@ function getRootOpts(command) {
 
 // lib/resolve-client.ts
 function resolveClientOpts(command, opts = {}) {
+  const result = resolveClientOptsPartial(command, opts);
+  if (!result.workspaceId) {
+    console.error("Error: cannot determine workspace. Set ALOOK_WORKSPACE_ID env var or use --workspace flag.");
+    process.exit(1);
+  }
+  return result;
+}
+function resolveClientOptsPartial(command, opts = {}) {
   const parentOpts = getRootOpts(command);
   const cfg = loadCLIConfigForProfile(parentOpts.profile);
   const serverUrl = parentOpts.server || process.env.ALOOK_SERVER_URL || cfg.server_url;
@@ -22206,16 +22244,12 @@ function resolveClientOpts(command, opts = {}) {
     ws = workspaces[0];
   }
   const envToken = process.env.ALOOK_TOKEN;
-  const token = envToken || ws?.token;
+  const token = envToken || ws?.token || cfg.session_token;
   if (!token) {
     console.error(`Error: not registered. Run '${cmdPrefix()} register --token <token>' first.`);
     process.exit(1);
   }
-  const workspaceId = ws?.id || envWorkspaceId;
-  if (!workspaceId) {
-    console.error("Error: cannot determine workspace. Set ALOOK_WORKSPACE_ID env var or use --workspace flag.");
-    process.exit(1);
-  }
+  const workspaceId = ws?.id || envWorkspaceId || undefined;
   return { serverUrl, token, workspaceId };
 }
 
@@ -23231,11 +23265,40 @@ import { readFileSync as readFileSync14 } from "fs";
 function slugify2(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
 }
+function sleep4(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function resolveWorkspaceId(client, configName) {
+  let workspaces;
+  try {
+    workspaces = await client.getJSON("/api/workspaces");
+  } catch (err) {
+    console.error(`Error: failed to fetch workspaces: ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+  for (const ws of workspaces) {
+    try {
+      const agents = await client.getJSON(`/api/agents?workspace_id=${ws.id}`);
+      if (agents.length === 0) {
+        return { workspaceId: ws.id, created: false };
+      }
+    } catch {}
+  }
+  const wsName = configName || "Personal";
+  try {
+    const newWs = await client.postJSON("/api/workspaces", { name: wsName, slug: slugify2(wsName) });
+    console.log(`Created workspace: ${newWs.name} (${newWs.id})`);
+    return { workspaceId: newWs.id, created: true };
+  } catch (err) {
+    console.error(`Error: failed to create workspace: ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+}
 function workspaceCommand() {
   const cmd = new Command13("workspace").description("Manage workspaces");
   cmd.command("init").description("Initialize a workspace from a JSON configuration file").requiredOption("--json-file <path>", "Path to the JSON configuration file").option("--name <name>", "Workspace name (overrides JSON)").option("--json", "Output as JSON").action(async (opts, command) => {
-    const { serverUrl, token, workspaceId } = resolveClientOpts(command);
-    const client = new APIClient(serverUrl, token, workspaceId);
+    const { serverUrl, token, workspaceId: resolvedWorkspaceId } = resolveClientOptsPartial(command);
+    const client = new APIClient(serverUrl, token, resolvedWorkspaceId);
     let configJson;
     try {
       configJson = readFileSync14(opts.jsonFile, "utf-8");
@@ -23254,9 +23317,89 @@ function workspaceCommand() {
       console.error("Error: JSON must contain a 'members' array with at least one member");
       process.exit(1);
     }
+    let targetWorkspaceId = resolvedWorkspaceId;
+    if (!targetWorkspaceId) {
+      const resolved = await resolveWorkspaceId(client, opts.name || config2.name);
+      targetWorkspaceId = resolved.workspaceId;
+      const parentOpts = getRootOpts(command);
+      const cfg = loadCLIConfigForProfile(parentOpts.profile);
+      const registeredWs = cfg.watched_workspaces?.find((w) => w.status === "registered" && !w.id);
+      if (registeredWs) {
+        try {
+          await client.postJSON("/api/machine-tokens/bind-workspace", { workspace_id: targetWorkspaceId });
+          console.log("Machine token bound to workspace. Waiting for runtime registration...");
+        } catch (err) {
+          console.warn(`Warning: bind-workspace failed: ${err instanceof Error ? err.message : err}`);
+        }
+      }
+      let runtimes2 = [];
+      const wsClient = new APIClient(serverUrl, token, targetWorkspaceId);
+      for (let attempt = 0;attempt < 15; attempt++) {
+        try {
+          runtimes2 = await wsClient.getJSON("/api/runtimes");
+          if (runtimes2.length > 0)
+            break;
+        } catch {}
+        await sleep4(1000);
+      }
+      if (runtimes2.length === 0) {
+        console.error(`Error: No daemon registered after waiting. Run '${cmdPrefix()} daemon start' first.`);
+        process.exit(1);
+      }
+      const OFFLINE_THRESHOLD_MS3 = 5 * 60 * 1000;
+      const now2 = Date.now();
+      const onlineRuntime2 = runtimes2.find((r) => {
+        if (!r.machineLastSeenAt)
+          return false;
+        const lastSeen = new Date(r.machineLastSeenAt.includes("Z") ? r.machineLastSeenAt : r.machineLastSeenAt + "Z").getTime();
+        return now2 - lastSeen < OFFLINE_THRESHOLD_MS3;
+      });
+      const runtime2 = onlineRuntime2 || runtimes2[0];
+      const members2 = config2.members.map((m) => ({
+        ...m,
+        runtime_id: runtime2.id
+      }));
+      const payload2 = {
+        name: opts.name || config2.name,
+        scenario: config2.scenario,
+        members: members2
+      };
+      try {
+        const res = await wsClient.postJSON("/api/studios", payload2);
+        try {
+          const freshCfg = loadCLIConfigForProfile(parentOpts.profile);
+          const watched = freshCfg.watched_workspaces || [];
+          const existing = watched.find((w) => w.id === targetWorkspaceId);
+          if (existing) {
+            existing.status = "active";
+            existing.name = res.workspace.name;
+          } else {
+            watched.push({ id: targetWorkspaceId, name: res.workspace.name, token, status: "active", agent_ids: [] });
+          }
+          freshCfg.watched_workspaces = watched;
+          saveCLIConfigForProfile(parentOpts.profile, freshCfg);
+        } catch {}
+        if (opts.json)
+          return printJSON(res);
+        console.log(`
+Workspace initialized: ${res.studio.name || res.workspace.name}`);
+        console.log("Agents created:");
+        for (const agent2 of res.agents) {
+          const email3 = agent2.email_handle ? toAlookAddress(agent2.email_handle) : "no email";
+          console.log(`  - ${agent2.name} (${email3})`);
+        }
+        console.log(`
+  Open: ${serverUrl}/w/${res.workspace.slug}`);
+      } catch (err) {
+        console.error(`Error: failed to create workspace: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+      }
+      return;
+    }
+    let targetClient = new APIClient(serverUrl, token, targetWorkspaceId);
     let runtimes;
     try {
-      runtimes = await client.getJSON("/api/runtimes");
+      runtimes = await targetClient.getJSON("/api/runtimes");
     } catch (err) {
       console.error(`Error: failed to fetch runtimes: ${err instanceof Error ? err.message : err}`);
       process.exit(1);
@@ -23274,14 +23417,12 @@ function workspaceCommand() {
       return now - lastSeen < OFFLINE_THRESHOLD_MS2;
     });
     let runtime = onlineRuntime || runtimes[0];
-    let targetWorkspaceId = workspaceId;
-    let targetClient = client;
     try {
-      const agents = await client.getJSON(`/api/agents?workspace_id=${workspaceId}`);
+      const agents = await targetClient.getJSON(`/api/agents?workspace_id=${targetWorkspaceId}`);
       if (agents.length > 0) {
         console.log("Current workspace has existing agents. Creating a new workspace...");
         const wsName = opts.name || config2.name || "New Workspace";
-        const newWs = await client.postJSON("/api/workspaces", { name: wsName, slug: slugify2(wsName) });
+        const newWs = await targetClient.postJSON("/api/workspaces", { name: wsName, slug: slugify2(wsName) });
         targetWorkspaceId = newWs.id;
         targetClient = new APIClient(serverUrl, token, targetWorkspaceId);
         console.log(`Created workspace: ${newWs.name} (${newWs.id})`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alook/cli",
-  "version": "0.0.121",
+  "version": "0.0.122",
   "description": "Alook CLI — Enable Your Person Colleague",
   "license": "Apache-2.0",
   "homepage": "https://github.com/alookai/alook#readme",