@team-ai/teamai-cli 0.30.1 → 0.30.2

package/dist/cli.js

@@ -61820,6 +61820,39 @@ function mergeWorkspaceBindings(existing2, incoming, canonicalKey) {
   if (!base.ideType) base.ideType = existing2.ideType ?? incoming.ideType;
   return base;
 }
+function workspaceEnrollmentsOf(config) {
+  return config.workspaceEnrollments ??= {};
+}
+async function inferWorkspaceEnrollments(config) {
+  const inferred = {};
+  const add = async (workspacePath, enrolledAt = config.createdAt, ideType) => {
+    const canonical2 = await canonicalizeWorkspacePath(workspacePath);
+    inferred[canonical2] ??= { enrolledAt, ...ideType ? { ideType } : {} };
+  };
+  for (const [workspacePath, binding] of Object.entries(config.workspaceBindings)) {
+    if (binding.projectId > 0) await add(workspacePath, binding.boundAt, 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;
@@ -61827,8 +61860,14 @@ async function loadLocalAgentConfig(options2 = {}) {
     const config = {
       ...fileConfig,
       endpoint: normalizeEndpoint(fileConfig.endpoint),
+      workspaceEnrollments: fileConfig.workspaceEnrollments ?? {},
       workspaceBindings: fileConfig.workspaceBindings ?? {}
     };
+    let enrollmentMigrationChanged = false;
+    if (fileConfig.workspaceEnrollments === void 0) {
+      config.workspaceEnrollments = await inferWorkspaceEnrollments(config);
+      enrollmentMigrationChanged = true;
+    }
     const removedLegacyPaths = [];
     for (const [wsPath, binding] of Object.entries(config.workspaceBindings)) {
       if ("groupId" in binding && !("projectId" in binding)) {
@@ -61857,7 +61896,14 @@ async function loadLocalAgentConfig(options2 = {}) {
       migrated[canonicalKey] = mergeWorkspaceBindings(migrated[canonicalKey], binding, canonicalKey);
     }
     config.workspaceBindings = migrated;
-    if (migrationChanged && !options2.dryRun) {
+    const migratedEnrollments = {};
+    for (const [wsPath, enrollment] of Object.entries(config.workspaceEnrollments)) {
+      const canonicalKey = await canonicalizeWorkspacePath(wsPath);
+      if (canonicalKey !== wsPath || migratedEnrollments[canonicalKey]) migrationChanged = true;
+      migratedEnrollments[canonicalKey] ??= enrollment;
+    }
+    config.workspaceEnrollments = migratedEnrollments;
+    if ((migrationChanged || enrollmentMigrationChanged) && !options2.dryRun) {
       await saveLocalAgentConfig(config);
     }
     return config;
@@ -61872,6 +61918,7 @@ async function loadLocalAgentConfig(options2 = {}) {
       endpoint,
       token,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      workspaceEnrollments: {},
       workspaceBindings: {}
     };
     if (options2.dryRun) return backfilled;
@@ -61889,6 +61936,7 @@ async function loadLocalAgentConfig(options2 = {}) {
     endpoint: normalizeEndpoint(envEndpoint),
     token: process.env.TEAMAI_API_TOKEN ?? process.env.TEAMAI_TOKEN,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workspaceEnrollments: {},
     workspaceBindings: {}
   };
 }
@@ -61896,6 +61944,7 @@ async function saveLocalAgentConfig(config) {
   await writeJsonAtomic(getConfigPath(), {
     ...config,
     endpoint: normalizeEndpoint(config.endpoint),
+    workspaceEnrollments: config.workspaceEnrollments ?? {},
     workspaceBindings: config.workspaceBindings ?? {}
   });
 }
@@ -62302,6 +62351,10 @@ async function persistWorkspaceBinding(config, cwd, resolvedPath, projectId, pro
   }
   await saveLocalAgentConfig(config);
 }
+async function enrollWorkspace(config, resolvedPath) {
+  const enrollments = workspaceEnrollmentsOf(config);
+  enrollments[resolvedPath] ??= { enrolledAt: (/* @__PURE__ */ new Date()).toISOString() };
+}
 async function inheritWorktreeBinding(config, cwd, resolvedPath) {
   const anchors = await resolveAnchors(cwd);
   if (!anchors || anchors.projectAnchor === anchors.workspaceRoot) return false;
@@ -62321,6 +62374,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 (!workspaceEnrollmentsOf(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,6 +62392,7 @@ async function bindWorkspaceToProject(workspacePath, projectId) {
   return binding;
 }
 async function ensureWorkspaceBinding(config, workspacePath, sessionId, cwd) {
+  if (!workspaceEnrollmentsOf(config)[workspacePath]) return;
   if (config.workspaceBindings[workspacePath]) return;
   if (await inheritWorktreeBinding(config, cwd, workspacePath)) return;
   const markerKey = sessionId || `ppid-${process.ppid}`;
@@ -62382,6 +62441,7 @@ function isBindPromptTool(tool) {
   return kind === "codebuddy" || kind === "workbuddy";
 }
 async function emitBindingHint(config, workspacePath, sessionId, cwd) {
+  if (!workspaceEnrollmentsOf(config)[workspacePath]) return;
   if (config.workspaceBindings[workspacePath]) return;
   if (await inheritWorktreeBinding(config, cwd, workspacePath)) return;
   const markerKey = sessionId || `ppid-${process.ppid}`;
@@ -62581,9 +62641,14 @@ async function scanModelsFromDisk(tool, workspacePath) {
 }
 async function pruneDeadWorkspaceBindings(config) {
   let changed = false;
-  for (const workspacePath of Object.keys(config.workspaceBindings)) {
+  const allPaths = /* @__PURE__ */ new Set([
+    ...Object.keys(config.workspaceBindings),
+    ...Object.keys(workspaceEnrollmentsOf(config))
+  ]);
+  for (const workspacePath of allPaths) {
     if (await isUserHomeDir(workspacePath)) {
       delete config.workspaceBindings[workspacePath];
+      delete workspaceEnrollmentsOf(config)[workspacePath];
       changed = true;
       continue;
     }
@@ -62592,6 +62657,7 @@ async function pruneDeadWorkspaceBindings(config) {
     } catch (error2) {
       if (error2.code === "ENOENT") {
         delete config.workspaceBindings[workspacePath];
+        delete workspaceEnrollmentsOf(config)[workspacePath];
         changed = true;
       } else {
         log.debug(
@@ -62604,19 +62670,26 @@ async function pruneDeadWorkspaceBindings(config) {
 }
 function stampWorkspaceTool(config, currentPath, tool) {
   if (!currentPath) return false;
+  const enrollment = workspaceEnrollmentsOf(config)[currentPath];
+  if (!enrollment) return false;
   const binding = config.workspaceBindings[currentPath];
-  if (!binding) return false;
   const normalized = normalizeAgentType(tool);
-  if (binding.ideType === normalized) return false;
-  binding.ideType = normalized;
-  return true;
+  let changed = false;
+  if (enrollment.ideType !== normalized) {
+    enrollment.ideType = normalized;
+    changed = true;
+  }
+  if (binding && binding.ideType !== normalized) {
+    binding.ideType = normalized;
+    changed = true;
+  }
+  return changed;
 }
 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(workspaceEnrollmentsOf(config)).filter((wsPath) => {
+    const enrollment = workspaceEnrollmentsOf(config)[wsPath];
     const b2 = config.workspaceBindings[wsPath];
-    const wsTool = (b2?.ideType || void 0) ?? (wsPath === currentPath ? currentTool : void 0);
+    const wsTool = enrollment.ideType ?? b2?.ideType ?? (wsPath === currentPath ? currentTool : void 0);
     return wsTool === currentTool;
   });
 }
@@ -62676,9 +62749,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 && wsBinding.projectId > 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 +62780,7 @@ async function buildSyncPayload(config, context) {
         path: wsPath,
         name: path76.basename(wsPath),
         ide_type: currentTool,
-        project_id: wsBinding?.projectId
+        ...wsBinding && wsBinding.projectId > 0 ? { project_id: wsBinding.projectId } : {}
       };
     });
   }
@@ -63779,9 +63852,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 && workspaceEnrollmentsOf(config)[workspacePath] === void 0) {
     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 +64374,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 (!workspaceEnrollmentsOf(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 +64470,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 && workspaceEnrollmentsOf(config)[workspacePath]) {
       const sid = context.event?.sessionId;
       if (context.event?.type === "session_start") {
         await ensureWorkspaceBinding(config, workspacePath, sid, context.cwd);
@@ -64404,8 +64495,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 +64667,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(),
+    workspaceEnrollments: existing2?.workspaceEnrollments ?? {},
     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) {
@@ -64829,7 +64922,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 (!workspaceEnrollmentsOf(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 +66099,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 +106804,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.2",
   "description": "TeamAI — Make Every Team AI Native (skill sync + shared knowledge base, powered by Git)",
   "type": "module",
   "bin": {