@team-ai/teamai-cli 0.30.1 → 0.30.3

package/dist/cli.js

@@ -61809,23 +61809,99 @@ async function canonicalizeWorkspacePath(value) {
 }
 function mergeWorkspaceBindings(existing2, incoming, canonicalKey) {
   if (!existing2) return incoming;
-  const existingReal = existing2.projectId !== 0;
-  const incomingReal = incoming.projectId !== 0;
+  const rank2 = (binding) => (binding.projectId ?? 0) > 0 ? 2 : binding.projectId === 0 ? 1 : 0;
+  const existingRank = rank2(existing2);
+  const incomingRank = rank2(incoming);
+  const existingReal = existingRank === 2;
+  const incomingReal = incomingRank === 2;
   if (existingReal && incomingReal && existing2.projectId !== incoming.projectId) {
     log.warn(
       `local-agent: workspace ${canonicalKey} has conflicting project bindings (${existing2.projectId} vs ${incoming.projectId}); keeping ${existing2.projectId}`
     );
   }
-  const base = existingReal || !incomingReal ? { ...existing2 } : { ...incoming };
+  const base = existingRank >= incomingRank ? { ...existing2 } : { ...incoming };
+  base.enrolledAt ??= existing2.enrolledAt ?? incoming.enrolledAt;
   if (!base.ideType) base.ideType = existing2.ideType ?? incoming.ideType;
   return base;
 }
+function isWorkspaceEnrolled(config, workspacePath) {
+  return config.workspaceBindings[workspacePath]?.enrolledAt !== void 0;
+}
+function hasWorkspaceBindingDecision(binding) {
+  return binding?.projectId !== void 0;
+}
+async function inferWorkspaceEnrollments(config) {
+  const inferred = {};
+  const add = async (workspacePath, enrolledAt = config.createdAt, ideType) => {
+    const canonical2 = await canonicalizeWorkspacePath(workspacePath);
+    inferred[canonical2] ??= { enrolledAt, ...ideType ? { ideType } : {} };
+  };
+  const inheritedAnchors = /* @__PURE__ */ new Set();
+  const missingBindings = /* @__PURE__ */ new Set();
+  const anchorsByPath = /* @__PURE__ */ new Map();
+  const positiveBindings = Object.entries(config.workspaceBindings).filter(([, binding]) => (binding.projectId ?? 0) > 0);
+  for (const [workspacePath] of positiveBindings) {
+    try {
+      await fs35.promises.stat(workspacePath);
+    } catch (error2) {
+      if (error2.code === "ENOENT") missingBindings.add(workspacePath);
+      continue;
+    }
+    const anchors = await resolveAnchors(workspacePath);
+    anchorsByPath.set(workspacePath, anchors);
+    if (anchors && anchors.projectAnchor !== anchors.workspaceRoot) {
+      inheritedAnchors.add(await canonicalizeWorkspacePath(anchors.projectAnchor));
+    }
+  }
+  const bindingTransactions = /* @__PURE__ */ new Map();
+  for (const [workspacePath, binding] of positiveBindings) {
+    if (!binding.boundAt) continue;
+    const key = `${binding.projectId}\0${binding.boundAt}`;
+    const paths = bindingTransactions.get(key) ?? [];
+    paths.push(workspacePath);
+    bindingTransactions.set(key, paths);
+  }
+  for (const paths of bindingTransactions.values()) {
+    if (!paths.some((workspacePath) => missingBindings.has(workspacePath))) continue;
+    for (const workspacePath of paths) {
+      if (missingBindings.has(workspacePath)) continue;
+      const anchors = anchorsByPath.get(workspacePath);
+      if (anchors && anchors.projectAnchor === anchors.workspaceRoot) inheritedAnchors.add(workspacePath);
+    }
+  }
+  for (const [workspacePath, binding] of Object.entries(config.workspaceBindings)) {
+    if ((binding.projectId ?? 0) > 0 && !missingBindings.has(workspacePath) && !inheritedAnchors.has(workspacePath)) {
+      await add(workspacePath, binding.boundAt ?? config.createdAt, binding.ideType);
+    }
+  }
+  const manifest = await readJson(getManifestPath());
+  for (const key of Object.keys(manifest?.scopes ?? {})) {
+    const parsed = parseScopeKey(key);
+    if (parsed.scope === "project" && parsed.workspacePath) await add(parsed.workspacePath);
+  }
+  const models = await readJson(getModelManifestPath());
+  for (const workspacePath of Object.keys(models?.workspaceModels ?? {})) await add(workspacePath);
+  const projectHomes = await listDirs(path76.join(getTeamaiHomePath(), "projects")).catch(() => []);
+  const mcpOwnershipFiles = [
+    path76.join(getTeamaiHomePath(), "managed-local-mcp.json"),
+    ...projectHomes.map((dir) => path76.join(getTeamaiHomePath(), "projects", dir, "managed-local-mcp.json"))
+  ];
+  for (const file of mcpOwnershipFiles) {
+    const records2 = await readJson(file);
+    for (const [key, owned] of Object.entries(records2 ?? {})) {
+      const match = /^[^:]+:local:(.+)$/.exec(key);
+      if (match?.[1] && owned.length > 0) await add(match[1]);
+    }
+  }
+  return inferred;
+}
 async function loadLocalAgentConfig(options2 = {}) {
   const fileConfig = await readJson(getConfigPath());
   if (fileConfig && "disabled" in fileConfig && fileConfig.disabled === true) return null;
   if (fileConfig && "endpoint" in fileConfig && fileConfig.endpoint) {
+    const { workspaceEnrollments: legacyEnrollments, ...storedConfig } = fileConfig;
     const config = {
-      ...fileConfig,
+      ...storedConfig,
       endpoint: normalizeEndpoint(fileConfig.endpoint),
       workspaceBindings: fileConfig.workspaceBindings ?? {}
     };
@@ -61836,20 +61912,15 @@ async function loadLocalAgentConfig(options2 = {}) {
         removedLegacyPaths.push(wsPath);
       }
     }
+    let migrationChanged = removedLegacyPaths.length > 0;
     if (removedLegacyPaths.length > 0 && options2.dryRun) {
       log.info(`[dry-run] Would remove ${removedLegacyPaths.length} legacy group-based workspace binding(s).`);
     } else if (removedLegacyPaths.length > 0) {
       log.warn(
         `Removed ${removedLegacyPaths.length} legacy group-based workspace binding(s); you will be prompted to re-bind on the next session.`
       );
-      try {
-        await saveLocalAgentConfig(config);
-      } catch (e) {
-        log.debug(`local-agent: failed to persist binding cleanup: ${e.message}`);
-      }
     }
     const migrated = {};
-    let migrationChanged = false;
     for (const [wsPath, binding] of Object.entries(config.workspaceBindings)) {
       const canonicalKey = await canonicalizeWorkspacePath(wsPath);
       if (canonicalKey !== wsPath) migrationChanged = true;
@@ -61857,6 +61928,20 @@ async function loadLocalAgentConfig(options2 = {}) {
       migrated[canonicalKey] = mergeWorkspaceBindings(migrated[canonicalKey], binding, canonicalKey);
     }
     config.workspaceBindings = migrated;
+    if (fileConfig.workspaceStateVersion !== 1) {
+      const enrollments = legacyEnrollments ?? await inferWorkspaceEnrollments(config);
+      for (const [wsPath, enrollment] of Object.entries(enrollments)) {
+        const canonicalKey = await canonicalizeWorkspacePath(wsPath);
+        const binding = config.workspaceBindings[canonicalKey] ?? {};
+        config.workspaceBindings[canonicalKey] = {
+          ...binding,
+          enrolledAt: binding.enrolledAt ?? enrollment.enrolledAt,
+          ideType: enrollment.ideType ?? binding.ideType
+        };
+      }
+      config.workspaceStateVersion = 1;
+      migrationChanged = true;
+    }
     if (migrationChanged && !options2.dryRun) {
       await saveLocalAgentConfig(config);
     }
@@ -61872,6 +61957,7 @@ async function loadLocalAgentConfig(options2 = {}) {
       endpoint,
       token,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      workspaceStateVersion: 1,
       workspaceBindings: {}
     };
     if (options2.dryRun) return backfilled;
@@ -61889,6 +61975,7 @@ async function loadLocalAgentConfig(options2 = {}) {
     endpoint: normalizeEndpoint(envEndpoint),
     token: process.env.TEAMAI_API_TOKEN ?? process.env.TEAMAI_TOKEN,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workspaceStateVersion: 1,
     workspaceBindings: {}
   };
 }
@@ -61896,6 +61983,7 @@ async function saveLocalAgentConfig(config) {
   await writeJsonAtomic(getConfigPath(), {
     ...config,
     endpoint: normalizeEndpoint(config.endpoint),
+    workspaceStateVersion: 1,
     workspaceBindings: config.workspaceBindings ?? {}
   });
 }
@@ -62302,11 +62390,18 @@ async function persistWorkspaceBinding(config, cwd, resolvedPath, projectId, pro
   }
   await saveLocalAgentConfig(config);
 }
+async function enrollWorkspace(config, resolvedPath) {
+  const binding = config.workspaceBindings[resolvedPath] ?? {};
+  config.workspaceBindings[resolvedPath] = {
+    ...binding,
+    enrolledAt: binding.enrolledAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
 async function inheritWorktreeBinding(config, cwd, resolvedPath) {
   const anchors = await resolveAnchors(cwd);
   if (!anchors || anchors.projectAnchor === anchors.workspaceRoot) return false;
   const anchorBinding = config.workspaceBindings[anchors.projectAnchor];
-  if (!anchorBinding) return false;
+  if (!hasWorkspaceBindingDecision(anchorBinding)) return false;
   config.workspaceBindings[resolvedPath] = {
     ...config.workspaceBindings[resolvedPath],
     projectId: anchorBinding.projectId,
@@ -62321,6 +62416,11 @@ async function bindWorkspaceToProject(workspacePath, projectId) {
   if (!config) {
     throw new Error("HTTP local agent is not initialized. Run `teamai init --http <ENDPOINT> --token <API_TOKEN>` first.");
   }
+  if (!isWorkspaceEnrolled(config, workspacePath)) {
+    throw new Error(
+      "Current workspace is not enrolled. Run `teamai init --http <ENDPOINT> --token <API_TOKEN>` here first."
+    );
+  }
   const projects = await fetchUserProjects(config);
   const project = projectId ? projects.find((item) => item.id === projectId) : await promptForProjectBinding(workspacePath, projects);
   if (!project) return null;
@@ -62334,7 +62434,8 @@ async function bindWorkspaceToProject(workspacePath, projectId) {
   return binding;
 }
 async function ensureWorkspaceBinding(config, workspacePath, sessionId, cwd) {
-  if (config.workspaceBindings[workspacePath]) return;
+  if (!isWorkspaceEnrolled(config, workspacePath)) return;
+  if (hasWorkspaceBindingDecision(config.workspaceBindings[workspacePath])) return;
   if (await inheritWorktreeBinding(config, cwd, workspacePath)) return;
   const markerKey = sessionId || `ppid-${process.ppid}`;
   const hintMarker = path76.join(os9.tmpdir(), `teamai-bind-session-${markerKey}`);
@@ -62382,7 +62483,8 @@ function isBindPromptTool(tool) {
   return kind === "codebuddy" || kind === "workbuddy";
 }
 async function emitBindingHint(config, workspacePath, sessionId, cwd) {
-  if (config.workspaceBindings[workspacePath]) return;
+  if (!isWorkspaceEnrolled(config, workspacePath)) return;
+  if (hasWorkspaceBindingDecision(config.workspaceBindings[workspacePath])) return;
   if (await inheritWorktreeBinding(config, cwd, workspacePath)) return;
   const markerKey = sessionId || `ppid-${process.ppid}`;
   const hintMarker = path76.join(os9.tmpdir(), `teamai-bind-hint-${markerKey}`);
@@ -62605,18 +62707,19 @@ async function pruneDeadWorkspaceBindings(config) {
 function stampWorkspaceTool(config, currentPath, tool) {
   if (!currentPath) return false;
   const binding = config.workspaceBindings[currentPath];
-  if (!binding) return false;
+  if (!binding?.enrolledAt) return false;
   const normalized = normalizeAgentType(tool);
-  if (binding.ideType === normalized) return false;
-  binding.ideType = normalized;
-  return true;
+  if (binding.ideType !== normalized) {
+    binding.ideType = normalized;
+    return true;
+  }
+  return false;
 }
 function selectToolWorkspaces(config, currentPath, currentTool) {
-  const paths = new Set(Object.keys(config.workspaceBindings));
-  if (currentPath) paths.add(currentPath);
-  return Array.from(paths).filter((wsPath) => {
+  return Object.keys(config.workspaceBindings).filter((wsPath) => {
     const b2 = config.workspaceBindings[wsPath];
-    const wsTool = (b2?.ideType || void 0) ?? (wsPath === currentPath ? currentTool : void 0);
+    if (!b2.enrolledAt) return false;
+    const wsTool = b2.ideType ?? (wsPath === currentPath ? currentTool : void 0);
     return wsTool === currentTool;
   });
 }
@@ -62676,9 +62779,9 @@ async function buildReportPayload(config, context) {
         const workspace = {
           path: wsPath,
           name: path76.basename(wsPath),
-          ide_type: currentTool,
-          project_id: wsBinding?.projectId
+          ide_type: currentTool
         };
+        if ((wsBinding?.projectId ?? 0) > 0) workspace.project_id = wsBinding.projectId;
         if (wsScope.skills.length > 0) workspace.skills = wsScope.skills;
         if (wsScope.rules.length > 0) workspace.rules = wsScope.rules;
         const wsMcps = await scanMcpFromManifest("project", tool, wsPath);
@@ -62707,7 +62810,7 @@ async function buildSyncPayload(config, context) {
         path: wsPath,
         name: path76.basename(wsPath),
         ide_type: currentTool,
-        project_id: wsBinding?.projectId
+        ...(wsBinding?.projectId ?? 0) > 0 ? { project_id: wsBinding.projectId } : {}
       };
     });
   }
@@ -63779,9 +63882,9 @@ async function applyModelConfig(config, command, context) {
   if (scope === "project" && !workspacePath) {
     throw new Error("apply_model_config: workspace command is missing workspace_path");
   }
-  if (workspacePath && config.workspaceBindings[workspacePath] === void 0) {
+  if (workspacePath && !isWorkspaceEnrolled(config, workspacePath)) {
     throw new Error(
-      `apply_model_config: workspace "${path76.basename(workspacePath)}" is not a registered binding`
+      `apply_model_config: workspace "${path76.basename(workspacePath)}" is not enrolled`
     );
   }
   if (agentKind === "claude" && workspacePath) {
@@ -64301,6 +64404,24 @@ async function runMcpCommand(config, command, context) {
   return command.version;
 }
 async function executeCommand(config, command, context) {
+  if (normalizeScope(command.scope) === "project") {
+    const workspacePath2 = await resolveWorkspacePath(command.workspace_path ?? context.cwd);
+    if (!workspacePath2) throw new Error(`${command.type ?? "workspace command"} is missing workspace_path`);
+    if (!isWorkspaceEnrolled(config, workspacePath2)) {
+      throw new Error(`Workspace is not enrolled for TeamAI management: ${workspacePath2}`);
+    }
+    if (command.project_id !== void 0) {
+      if (!Number.isInteger(command.project_id) || command.project_id <= 0) {
+        throw new Error(`Workspace command has invalid project_id: ${command.project_id}`);
+      }
+      const binding = config.workspaceBindings[workspacePath2];
+      if (!binding || binding.projectId !== command.project_id) {
+        throw new Error(
+          `Workspace project binding does not match command project_id ${command.project_id}: ${workspacePath2}`
+        );
+      }
+    }
+  }
   if (command.type === "apply_model_config") {
     await applyModelConfig(config, command, context);
     return;
@@ -64379,9 +64500,9 @@ async function reportAndSyncLocalAgent(context) {
 async function syncLocalAgent(context) {
   const config = await loadLocalAgentConfig();
   if (!config) return false;
+  const workspacePath = await resolveWorkspacePath(context.cwd);
   if (isBindPromptEnabled() && isBindPromptTool(context.tool)) {
-    const workspacePath = await resolveWorkspacePath(context.cwd);
-    if (workspacePath) {
+    if (workspacePath && isWorkspaceEnrolled(config, workspacePath)) {
       const sid = context.event?.sessionId;
       if (context.event?.type === "session_start") {
         await ensureWorkspaceBinding(config, workspacePath, sid, context.cwd);
@@ -64404,8 +64525,7 @@ async function syncLocalAgent(context) {
       await maybeReconcilePlugins(context);
     }
     const pruned = await pruneDeadWorkspaceBindings(config);
-    const currentPath = await resolveWorkspacePath(context.cwd);
-    const stamped = stampWorkspaceTool(config, currentPath, context.tool ?? "workbuddy");
+    const stamped = stampWorkspaceTool(config, workspacePath, context.tool ?? "workbuddy");
     if (pruned || stamped) {
       await saveLocalAgentConfig(config);
     }
@@ -64577,17 +64697,20 @@ async function initLocalAgentHttp(options2) {
     throw new Error("HTTP endpoint is required.");
   }
   const existing2 = await loadLocalAgentConfig();
-  if (existing2 && !options2.force) {
-    throw new Error("HTTP local agent is already initialized. Re-run with --force to overwrite.");
+  if (existing2 && !options2.force && normalizeEndpoint(existing2.endpoint) !== endpoint) {
+    throw new Error("HTTP local agent is initialized with another endpoint. Re-run with --force to overwrite.");
   }
   const config = {
     endpoint,
-    token: options2.token,
+    token: options2.token ?? existing2?.token,
     createdAt: existing2?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    workspaceStateVersion: 1,
     workspaceBindings: existing2?.workspaceBindings ?? {},
     userGroupId: existing2?.userGroupId,
     userGroupName: existing2?.userGroupName
   };
+  const workspacePath = await resolveWorkspacePath(options2.workspacePath ?? process.cwd());
+  if (workspacePath) await enrollWorkspace(config, workspacePath);
   await ensureDir(getLocalAgentHome());
   await saveLocalAgentConfig(config);
   if (options2.token) {
@@ -64615,7 +64738,7 @@ async function pullLocalAgentForCwd(context) {
 async function describeLocalAgent(options2 = {}) {
   const config = await loadLocalAgentConfig(options2);
   if (!config) return null;
-  const boundProjects = Object.entries(config.workspaceBindings).filter(([, b2]) => b2.projectId !== 0).map(([workspacePath, b2]) => ({ path: workspacePath, projectName: b2.projectName, projectId: b2.projectId }));
+  const boundProjects = Object.entries(config.workspaceBindings).filter(([, b2]) => (b2.projectId ?? 0) > 0).map(([workspacePath, b2]) => ({ path: workspacePath, projectName: b2.projectName, projectId: b2.projectId }));
   const manifest = await loadManifest2();
   const counts = { skills: 0, rules: 0, claudemd: 0 };
   for (const scope of Object.values(manifest.scopes)) {
@@ -64829,7 +64952,18 @@ async function bindCurrentProject(options2) {
     if (!config) {
       throw new Error("Local agent not initialized. Run `teamai init --http` first.");
     }
-    await persistWorkspaceBinding(config, options2?.cwd ?? process.cwd(), workspacePath, 0, "__skipped__");
+    if (!isWorkspaceEnrolled(config, workspacePath)) {
+      throw new Error(
+        "Current workspace is not enrolled. Run `teamai init --http <ENDPOINT> --token <API_TOKEN>` here first."
+      );
+    }
+    await persistWorkspaceBinding(
+      config,
+      options2?.cwd ?? process.cwd(),
+      workspacePath,
+      0,
+      "__skipped__"
+    );
     log.info(`\u5DF2\u8DF3\u8FC7\u7ED1\u5B9A\uFF0C\u4EE5\u540E\u4E0D\u518D\u63D0\u793A\u6B64\u5DE5\u4F5C\u533A\u3002`);
     return;
   }
@@ -65995,7 +66129,13 @@ async function initHttp(url, options2) {
   await reconcileHooksForInit(teamConfig, localConfig2, filterAgents2);
   const { initLocalAgentHttp: initLocalAgentHttp2 } = await Promise.resolve().then(() => (init_local_agent(), local_agent_exports));
   try {
-    await initLocalAgentHttp2({ endpoint: url, token: options2.token, force: options2.force, filterAgents: filterAgents2 });
+    await initLocalAgentHttp2({
+      endpoint: url,
+      token: options2.token,
+      force: options2.force,
+      filterAgents: filterAgents2,
+      workspacePath: projectRoot ?? process.cwd()
+    });
   } catch (e) {
     log.debug(`Local agent init: ${e.message}`);
   }
@@ -106694,7 +106834,12 @@ async function sourceAddHttp(endpoint, options2) {
     return;
   }
   const { initLocalAgentHttp: initLocalAgentHttp2 } = await Promise.resolve().then(() => (init_local_agent(), local_agent_exports));
-  await initLocalAgentHttp2({ endpoint: trimmed2, token: options2.token, force: true });
+  await initLocalAgentHttp2({
+    endpoint: trimmed2,
+    token: options2.token,
+    force: true,
+    workspacePath: mainConfig?.projectRoot ?? process.cwd()
+  });
   log.success(`HTTP source added (${trimmed2}).`);
   log.info("It will report/sync on the next AI session (via the hook-dispatch hook already installed).");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-ai/teamai-cli",
-  "version": "0.30.1",
+  "version": "0.30.3",
   "description": "TeamAI — Make Every Team AI Native (skill sync + shared knowledge base, powered by Git)",
   "type": "module",
   "bin": {