@kendoo.agentdesk/agentdesk 0.26.0 → 0.27.0

package/CHANGELOG.md

@@ -8,7 +8,7 @@ All user-facing changes to AgentDesk. Each entry is tagged:
 
 Internal refactors, infrastructure changes, and architectural notes are not listed here.
 
-## [Unreleased]
+## [0.27.0] — 2026-07-06
 
 ### Added
 - `[UI]` Private-session sharing flow. When someone visits a session URL they don't own, they now see a friendly "Shh… this one's private" page with a one-click "Request access" button instead of a blank error. The session owner sees pending requests in a new header inbox and can grant viewer access for just that session or the whole project. Viewer-granted sessions show up in the teammate's sidebar tagged as a viewer.
@@ -16,6 +16,9 @@ Internal refactors, infrastructure changes, and architectural notes are not list
 ### Changed
 - `[Both]` Security improvements and hardening. No action required.
 
+### Fixed
+- `[CLI]` The daemon no longer shows projects from other accounts after switching logins on the same machine. Project registrations are now tied to the account that created them, and the daemon cross-checks the server's per-account project list on startup. Projects from before this fix are matched to your account automatically on the next daemon start.
+
 ## [0.22.0] — 2026-05-23
 
 ### Changed

package/cli/daemon.mjs

@@ -8,12 +8,12 @@ import { randomUUID } from "crypto";
 import WebSocket from "ws";
 import { detectProject } from "./detect.mjs";
 import { loadConfig } from "./config.mjs";
-import { getStoredApiKey } from "./login.mjs";
+import { getStoredApiKey, ensureAccountIdentity } from "./login.mjs";
 import { resolveTeam, generateTeamPrompt } from "./agents.mjs";
 import { buildPrompt } from "./prompt.mjs";
 import { createStreamParser } from "./stream-parser.mjs";
 import { runOrchestrator, runPhasedOrchestrator } from "./orchestrator.mjs";
-import { getRegisteredProjects, registerLocalProject } from "./projects.mjs";
+import { getRegisteredProjects, registerLocalProject, claimLocalProjects } from "./projects.mjs";
 import { buildTrackerUrl } from "./tracker-url.mjs";
 import { fileURLToPath } from "url";
 import { dirname } from "path";
@@ -150,46 +150,100 @@ export async function runDaemon() {
     process.exit(1);
   }
 
-  // 2. Load registered projects — local registry first, then server fallback
+  // 2. Load registered projects, scoped to the logged-in account (AD-64).
+  // The local registry is machine-global — it accumulates projects from
+  // every account ever used on this machine — so the server's per-account
+  // project list is the authority on what this account may see.
   const agentdeskServer = process.env.AGENTDESK_SERVER || "https://agentdesk.live";
-  let allProjects = getRegisteredProjects();
+  const creds = await ensureAccountIdentity();
+  const accountId = creds?.accountId || null;
 
-  // Fallback: fetch from server if local registry is empty (pre-0.7.0 projects)
-  if (allProjects.length === 0) {
-    try {
-      const res = await fetch(`${agentdeskServer}/api/projects`, {
-        headers: { "x-api-key": apiKey },
-        signal: AbortSignal.timeout(5000),
-      });
-      if (res.ok) {
-        const serverProjects = await res.json();
-        if (Array.isArray(serverProjects) && serverProjects.length > 0) {
-          console.log(`  ${dim}Syncing ${serverProjects.length} project(s) from server...${reset}`);
-          for (const sp of serverProjects) {
+  let serverIds = null;
+  try {
+    const res = await fetch(`${agentdeskServer}/api/projects`, {
+      headers: { "x-api-key": apiKey },
+      signal: AbortSignal.timeout(5000),
+    });
+    if (res.ok) {
+      const serverProjects = await res.json();
+      if (Array.isArray(serverProjects)) {
+        serverIds = new Set(serverProjects.map(sp => sp.id || sp.name));
+
+        // Untagged local entries with no server row — either they predate
+        // server-side registration or were initialized under another login.
+        // Offer them to the server: it accepts free ids and silently no-ops
+        // ids owned by another account (AD-23), so re-fetching the list
+        // tells us which ones are actually ours.
+        const unclaimed = getRegisteredProjects().filter(p =>
+          !p.accountId && !serverIds.has(p.id) &&
+          existsSync(p.path) && existsSync(join(p.path, ".agentdesk.json")));
+        if (unclaimed.length > 0) {
+          for (const p of unclaimed) {
+            try {
+              await fetch(`${agentdeskServer}/api/projects`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", "x-api-key": apiKey },
+                body: JSON.stringify({ id: p.id, name: p.name, path: p.path }),
+                signal: AbortSignal.timeout(5000),
+              });
+            } catch {}
+          }
+          try {
+            const recheck = await fetch(`${agentdeskServer}/api/projects`, {
+              headers: { "x-api-key": apiKey },
+              signal: AbortSignal.timeout(5000),
+            });
+            if (recheck.ok) {
+              const confirmed = await recheck.json();
+              if (Array.isArray(confirmed)) {
+                serverIds = new Set(confirmed.map(sp => sp.id || sp.name));
+              }
+            }
+          } catch {}
+          for (const p of unclaimed) {
+            if (!serverIds.has(p.id)) {
+              console.log(`  ${yellow}Skipping ${p.name}${reset} ${dim}— registered to a different AgentDesk account${reset}`);
+            }
+          }
+        }
+
+        // Claim legacy untagged local entries the server confirmed as ours
+        claimLocalProjects([...serverIds], accountId);
+
+        // Sync server projects missing from the local registry (pre-0.7.0
+        // setups, or projects initialized on another machine)
+        const localIds = new Set(getRegisteredProjects().map(p => p.id));
+        const missing = serverProjects.filter(sp => !localIds.has(sp.id || sp.name));
+        if (missing.length > 0) {
+          console.log(`  ${dim}Syncing ${missing.length} project(s) from server...${reset}`);
+          for (const sp of missing) {
             const projectName = sp.id || sp.name;
             // If server has a valid path, use it
             if (sp.path && existsSync(sp.path)) {
-              registerLocalProject(projectName, sp.name, sp.path);
+              registerLocalProject(projectName, sp.name, sp.path, accountId);
               continue;
             }
             // Server has empty path — try to find the project locally
             const found = findProjectLocally(projectName);
             if (found) {
               console.log(`  ${dim}Found ${projectName} at ${found}${reset}`);
-              registerLocalProject(projectName, sp.name, found);
+              registerLocalProject(projectName, sp.name, found, accountId);
             } else {
               console.log(`  ${yellow}Could not find ${projectName} locally.${reset} Run ${cyan}agentdesk init${reset} in its directory.`);
             }
           }
-          allProjects = getRegisteredProjects();
         }
       }
-    } catch {
-      // Server not reachable — continue with local only
     }
+  } catch {
+    // Server not reachable — fall back to account-tagged local entries
   }
 
-  const projects = allProjects.filter(p => {
+  const projects = getRegisteredProjects(accountId).filter(p => {
+    // Server reachable → it is authoritative: hide entries it doesn't own,
+    // even legacy untagged ones (they may belong to another account).
+    // Offline → tagged + untagged entries from getRegisteredProjects().
+    if (serverIds && !serverIds.has(p.id) && !(accountId && p.accountId === accountId)) return false;
     if (!existsSync(p.path)) return false;
     if (!existsSync(join(p.path, ".agentdesk.json"))) return false;
     return true;

package/cli/init.mjs

@@ -20,7 +20,7 @@
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 import { loadConfig, pushConfig } from "./config.mjs";
-import { getStoredApiKey } from "./login.mjs";
+import { getStoredApiKey, ensureAccountIdentity } from "./login.mjs";
 import { registerLocalProject } from "./projects.mjs";
 import { checkTrackerPermissions } from "./tracker-check.mjs";
 import { autoMatchProject } from "./bootstrap.mjs";
@@ -535,7 +535,10 @@ async function runWizard({ cwd, apiKey, mode, projectKey }) {
     }
   }
 
-  registerLocalProject(computedKey, projectName, currentCwd);
+  // AD-64: tag the registry entry with the account so the daemon can scope
+  // its project list per login.
+  const accountId = (await ensureAccountIdentity())?.accountId || null;
+  registerLocalProject(computedKey, projectName, currentCwd, accountId);
 
   console.log("");
   const cmdPrefix = trackerTeamOrProjectId || computedKey.toUpperCase();

package/cli/login.mjs

@@ -17,13 +17,42 @@ function getEnvApiKey() {
 }
 
 export function getStoredApiKey() {
+  return getStoredCredentials()?.apiKey || null;
+}
+
+export function getStoredCredentials() {
   if (!existsSync(CREDENTIALS_PATH)) return null;
   try {
-    const creds = JSON.parse(readFileSync(CREDENTIALS_PATH, "utf-8"));
-    return creds.apiKey || null;
+    return JSON.parse(readFileSync(CREDENTIALS_PATH, "utf-8"));
+  } catch { return null; }
+}
+
+// AD-64: resolve which account an API key belongs to, so local project
+// registry entries can be scoped per account.
+async function fetchAccountIdentity(apiKey) {
+  try {
+    const res = await fetch(`${AGENTDESK_SERVER}/api/me`, {
+      headers: { "x-api-key": apiKey },
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!res.ok) return null;
+    const me = await res.json();
+    return me?.id ? { accountId: me.id, email: me.email || null } : null;
   } catch { return null; }
 }
 
+// Backfill accountId into credentials saved by pre-AD-64 versions.
+// Returns the (possibly updated) credentials object.
+export async function ensureAccountIdentity() {
+  const creds = getStoredCredentials();
+  if (!creds?.apiKey || creds.accountId) return creds;
+  const identity = await fetchAccountIdentity(creds.apiKey);
+  if (!identity) return creds;
+  const updated = { ...creds, ...identity };
+  writeFileSync(CREDENTIALS_PATH, JSON.stringify(updated, null, 2), { mode: 0o600 });
+  return updated;
+}
+
 export async function runLogin() {
   console.log("");
   console.log("  AgentDesk — Login");
@@ -120,7 +149,16 @@ export async function runLogin() {
         console.log("    agentdesk team TASK-123");
         console.log("");
 
-        setTimeout(() => { server.close(); process.exit(0); }, 500);
+        // AD-64: attach the account identity so the project registry can be
+        // scoped per account. Best-effort — login still succeeds without it.
+        fetchAccountIdentity(apiKey)
+          .then(identity => {
+            if (identity) {
+              writeFileSync(CREDENTIALS_PATH, JSON.stringify({ apiKey, name, ...identity, savedAt: Date.now() }, null, 2), { mode: 0o600 });
+            }
+          })
+          .catch(() => {})
+          .finally(() => { server.close(); process.exit(0); });
       } else {
         res.writeHead(400, { "Content-Type": "text/html" });
         res.end("<html><body><h2>Login failed. No API key received.</h2></body></html>");

package/cli/projects.mjs

@@ -1,4 +1,9 @@
 // Local project registry — tracks which projects have been initialized with `agentdesk init`
+//
+// AD-64: entries are tagged with the accountId they were registered under so
+// the daemon can scope its project list to the logged-in account. Entries
+// written by older versions have no accountId ("untagged") — the daemon
+// claims them for the active account when the server confirms ownership.
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join } from "path";
@@ -6,7 +11,7 @@ import { join } from "path";
 const CONFIG_DIR = join(process.env.HOME || process.env.USERPROFILE, ".agentdesk");
 const PROJECTS_PATH = join(CONFIG_DIR, "projects.json");
 
-export function getRegisteredProjects() {
+function readRegistry() {
   try {
     if (!existsSync(PROJECTS_PATH)) return [];
     const data = JSON.parse(readFileSync(PROJECTS_PATH, "utf-8"));
@@ -16,10 +21,28 @@ export function getRegisteredProjects() {
   }
 }
 
-export function registerLocalProject(id, name, path) {
-  const projects = getRegisteredProjects();
+function writeRegistry(projects) {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  }
+  writeFileSync(PROJECTS_PATH, JSON.stringify({ projects }, null, 2) + "\n", { mode: 0o600 });
+}
+
+// accountId: return only that account's entries plus legacy untagged ones
+// (callers that can reach the server should claimLocalProjects() first so
+// untagged entries get resolved rather than leaking across accounts).
+export function getRegisteredProjects(accountId) {
+  const projects = readRegistry();
+  if (!accountId) return projects;
+  return projects.filter(p => !p.accountId || p.accountId === accountId);
+}
+
+export function registerLocalProject(id, name, path, accountId) {
+  const projects = readRegistry();
   const existing = projects.findIndex(p => p.id === id);
   const entry = { id, name, path, registeredAt: Date.now() };
+  if (accountId) entry.accountId = accountId;
+  else if (existing >= 0 && projects[existing].accountId) entry.accountId = projects[existing].accountId;
 
   if (existing >= 0) {
     projects[existing] = entry;
@@ -27,8 +50,20 @@ export function registerLocalProject(id, name, path) {
     projects.push(entry);
   }
 
-  if (!existsSync(CONFIG_DIR)) {
-    mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  writeRegistry(projects);
+}
+
+// Tag untagged entries whose ids the server confirmed belong to accountId.
+export function claimLocalProjects(ids, accountId) {
+  if (!accountId || !ids?.length) return;
+  const idSet = new Set(ids);
+  const projects = readRegistry();
+  let changed = false;
+  for (const p of projects) {
+    if (!p.accountId && idSet.has(p.id)) {
+      p.accountId = accountId;
+      changed = true;
+    }
   }
-  writeFileSync(PROJECTS_PATH, JSON.stringify({ projects }, null, 2) + "\n", { mode: 0o600 });
+  if (changed) writeRegistry(projects);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kendoo.agentdesk/agentdesk",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "AI team orchestrator for Claude Code — run collaborative agent sessions from your terminal",
   "type": "module",
   "bin": {
@@ -22,7 +22,7 @@
     "server": "node server/index.mjs",
     "build": "vite build",
     "preview": "vite preview",
-    "test": "node --test tests/server.test.mjs tests/agents.test.mjs tests/homepage.test.mjs tests/sessionUtils.test.mjs tests/tracker-url.test.mjs tests/session-preflight.test.mjs tests/access.test.mjs tests/project-ownership.test.mjs tests/random-hex.test.mjs",
+    "test": "node --test tests/server.test.mjs tests/agents.test.mjs tests/homepage.test.mjs tests/sessionUtils.test.mjs tests/tracker-url.test.mjs tests/session-preflight.test.mjs tests/access.test.mjs tests/project-ownership.test.mjs tests/random-hex.test.mjs tests/projects-registry.test.mjs",
     "lint:changelog": "node scripts/lint-changelog.mjs",
     "prepublishOnly": "node scripts/lint-changelog.mjs"
   },