chatroom-cli 1.0.71 → 1.0.73

package/dist/index.js

@@ -10568,6 +10568,115 @@ var init_update = __esm(() => {
   execAsync = promisify(exec);
   log = console.log.bind(console);
 });
+
+// src/commands/register-agent.ts
+var exports_register_agent = {};
+__export(exports_register_agent, {
+  registerAgent: () => registerAgent
+});
+async function registerAgent(chatroomId, options) {
+  const client2 = await getConvexClient();
+  const { role, type } = options;
+  const sessionId = getSessionId();
+  if (!sessionId) {
+    const otherUrls = getOtherSessionUrls();
+    const currentUrl = getConvexUrl();
+    console.error(`❌ Not authenticated for: ${currentUrl}`);
+    if (otherUrls.length > 0) {
+      console.error(`
+\uD83D\uDCA1 You have sessions for other environments:`);
+      for (const url of otherUrls) {
+        console.error(`   • ${url}`);
+      }
+      console.error(`
+   To use a different environment, set CHATROOM_CONVEX_URL:`);
+      console.error(`   CHATROOM_CONVEX_URL=${otherUrls[0]} chatroom register-agent ...`);
+      console.error(`
+   Or to authenticate for the current environment:`);
+    }
+    console.error(`   chatroom auth login`);
+    process.exit(1);
+  }
+  if (!chatroomId || typeof chatroomId !== "string" || chatroomId.length < 20 || chatroomId.length > 40) {
+    console.error(`❌ Invalid chatroom ID format: ID must be 20-40 characters (got ${chatroomId?.length || 0})`);
+    process.exit(1);
+  }
+  if (!/^[a-zA-Z0-9_]+$/.test(chatroomId)) {
+    console.error(`❌ Invalid chatroom ID format: ID must contain only alphanumeric characters and underscores`);
+    process.exit(1);
+  }
+  const chatroom = await client2.query(api.chatrooms.get, {
+    sessionId,
+    chatroomId
+  });
+  if (!chatroom) {
+    console.error(`❌ Chatroom ${chatroomId} not found or access denied`);
+    process.exit(1);
+  }
+  if (type === "remote") {
+    try {
+      const machineInfo = ensureMachineRegistered();
+      let availableModels = [];
+      try {
+        const registry = getDriverRegistry();
+        for (const driver of registry.all()) {
+          if (driver.capabilities.dynamicModelDiscovery) {
+            const models = await driver.listModels();
+            availableModels = availableModels.concat(models);
+          }
+        }
+      } catch {}
+      await client2.mutation(api.machines.register, {
+        sessionId,
+        machineId: machineInfo.machineId,
+        hostname: machineInfo.hostname,
+        os: machineInfo.os,
+        availableHarnesses: machineInfo.availableHarnesses,
+        harnessVersions: machineInfo.harnessVersions,
+        availableModels
+      });
+      const agentHarness = machineInfo.availableHarnesses.length > 0 ? machineInfo.availableHarnesses[0] : undefined;
+      await client2.mutation(api.machines.saveTeamAgentConfig, {
+        sessionId,
+        chatroomId,
+        role,
+        type: "remote",
+        machineId: machineInfo.machineId,
+        agentHarness,
+        workingDir: process.cwd()
+      });
+      console.log(`✅ Registered as remote agent for role "${role}"`);
+      console.log(`   Machine: ${machineInfo.hostname} (${machineInfo.machineId})`);
+      console.log(`   Working directory: ${process.cwd()}`);
+      if (agentHarness) {
+        console.log(`   Agent harness: ${agentHarness}`);
+      }
+    } catch (error) {
+      console.error(`❌ Registration failed: ${error.message}`);
+      process.exit(1);
+    }
+  } else {
+    try {
+      await client2.mutation(api.machines.saveTeamAgentConfig, {
+        sessionId,
+        chatroomId,
+        role,
+        type: "custom"
+      });
+      console.log(`✅ Registered as custom agent for role "${role}"`);
+    } catch (error) {
+      console.error(`❌ Registration failed: ${error.message}`);
+      process.exit(1);
+    }
+  }
+}
+var init_register_agent = __esm(() => {
+  init_api3();
+  init_agent_drivers();
+  init_storage();
+  init_client2();
+  init_machine();
+});
 // ../../services/backend/prompts/base/cli/task-started/command.ts
 function taskStartedCommand(params) {
   const prefix = params.cliEnvPrefix || "";
@@ -10684,15 +10793,15 @@ var init_utils = __esm(() => {
   init_env();
 });
 
-// ../../services/backend/prompts/base/cli/init/context-gaining.ts
-var init_context_gaining = __esm(() => {
+// ../../services/backend/prompts/base/shared/getting-started-content.ts
+var init_getting_started_content = __esm(() => {
   init_utils();
 });
 
 // ../../services/backend/prompts/base/cli/index.ts
 var init_cli = __esm(() => {
   init_task_started();
-  init_context_gaining();
+  init_getting_started_content();
 });
 
 // ../../services/backend/prompts/base/cli/wait-for-task/command.ts
@@ -11749,6 +11858,7 @@ var init_report_progress = __esm(() => {
 // src/commands/backlog.ts
 var exports_backlog = {};
 __export(exports_backlog, {
+  scoreBacklog: () => scoreBacklog,
   resetBacklog: () => resetBacklog,
   reopenBacklog: () => reopenBacklog,
   patchBacklog: () => patchBacklog,
@@ -12047,6 +12157,70 @@ async function patchBacklog(chatroomId, options) {
     process.exit(1);
   }
 }
+async function scoreBacklog(chatroomId, options) {
+  const client2 = await getConvexClient();
+  const sessionId = getSessionId();
+  if (!sessionId) {
+    console.error(`❌ Not authenticated. Please run: chatroom auth login`);
+    process.exit(1);
+  }
+  if (!chatroomId || typeof chatroomId !== "string" || chatroomId.length < 20 || chatroomId.length > 40) {
+    console.error(`❌ Invalid chatroom ID format: ID must be 20-40 characters (got ${chatroomId?.length || 0})`);
+    process.exit(1);
+  }
+  if (!options.taskId || options.taskId.trim().length === 0) {
+    console.error(`❌ Task ID is required`);
+    process.exit(1);
+  }
+  if (options.complexity === undefined && options.value === undefined && options.priority === undefined) {
+    console.error(`❌ At least one of --complexity, --value, or --priority is required`);
+    console.error(`   Example: chatroom backlog score --task-id=... --complexity=medium --value=high`);
+    process.exit(1);
+  }
+  const validComplexity = ["low", "medium", "high"];
+  if (options.complexity !== undefined && !validComplexity.includes(options.complexity)) {
+    console.error(`❌ Invalid complexity: ${options.complexity}. Must be one of: ${validComplexity.join(", ")}`);
+    process.exit(1);
+  }
+  const validValue = ["low", "medium", "high"];
+  if (options.value !== undefined && !validValue.includes(options.value)) {
+    console.error(`❌ Invalid value: ${options.value}. Must be one of: ${validValue.join(", ")}`);
+    process.exit(1);
+  }
+  let priorityNum;
+  if (options.priority !== undefined) {
+    priorityNum = parseInt(options.priority, 10);
+    if (isNaN(priorityNum)) {
+      console.error(`❌ Invalid priority: ${options.priority}. Must be a number.`);
+      process.exit(1);
+    }
+  }
+  try {
+    await client2.mutation(api.tasks.patchTask, {
+      sessionId,
+      taskId: options.taskId,
+      complexity: options.complexity,
+      value: options.value,
+      priority: priorityNum
+    });
+    console.log("");
+    console.log("✅ Task scored");
+    console.log(`   ID: ${options.taskId}`);
+    if (options.complexity !== undefined) {
+      console.log(`   Complexity: ${options.complexity}`);
+    }
+    if (options.value !== undefined) {
+      console.log(`   Value: ${options.value}`);
+    }
+    if (priorityNum !== undefined) {
+      console.log(`   Priority: ${priorityNum}`);
+    }
+    console.log("");
+  } catch (error) {
+    console.error(`❌ Failed to score task: ${error.message}`);
+    process.exit(1);
+  }
+}
 async function markForReviewBacklog(chatroomId, options) {
   const client2 = await getConvexClient();
   const sessionId = getSessionId();
@@ -13237,7 +13411,23 @@ Listening for commands...`);
   }, async (result) => {
     if (!result.commands || result.commands.length === 0)
       return;
-    const parsed = result.commands.map(parseMachineCommand).filter((c) => c !== null);
+    const parsed = [];
+    for (const raw of result.commands) {
+      const command = parseMachineCommand(raw);
+      if (command !== null) {
+        parsed.push(command);
+      } else {
+        try {
+          await ctx.client.mutation(api.machines.ackCommand, {
+            sessionId: ctx.sessionId,
+            commandId: raw._id,
+            status: "failed",
+            result: `Invalid command: type="${raw.type}" missing required payload fields`
+          });
+          console.warn(`[${formatTimestamp()}] ⚠️  Acked invalid command ${raw._id} (type=${raw.type}) as failed`);
+        } catch {}
+      }
+    }
     enqueueCommands(parsed);
     await drainQueue();
   });
@@ -13770,6 +13960,18 @@ program2.command("update").description("Update the CLI to the latest version").a
   const { update: update2 } = await Promise.resolve().then(() => (init_update(), exports_update));
   await update2();
 });
+program2.command("register-agent").description("Register agent type for a chatroom role").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Role to register as (e.g., builder, reviewer)").requiredOption("--type <type>", "Agent type: remote or custom").action(async (options) => {
+  await maybeRequireAuth();
+  if (options.type !== "remote" && options.type !== "custom") {
+    console.error(`❌ Invalid agent type: "${options.type}". Must be "remote" or "custom".`);
+    process.exit(1);
+  }
+  const { registerAgent: registerAgent2 } = await Promise.resolve().then(() => (init_register_agent(), exports_register_agent));
+  await registerAgent2(options.chatroomId, {
+    role: options.role,
+    type: options.type
+  });
+});
 program2.command("wait-for-task").description("Join a chatroom and wait for tasks").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Role to join as (e.g., builder, reviewer)").option("--timeout <ms>", "Optional timeout in milliseconds (deprecated, use --duration)").option("--duration <duration>", 'How long to wait (e.g., "1m", "5m", "30s")').action(async (options) => {
   await maybeRequireAuth();
   const { waitForTask: waitForTask2, parseDuration: parseDuration2 } = await Promise.resolve().then(() => (init_wait_for_task(), exports_wait_for_task));
@@ -13949,6 +14151,11 @@ backlogCommand.command("patch-task").description("Update task scoring fields (co
   const { patchBacklog: patchBacklog2 } = await Promise.resolve().then(() => (init_backlog(), exports_backlog));
   await patchBacklog2(options.chatroomId, options);
 });
+backlogCommand.command("score").description("Score a backlog task by complexity, value, and priority").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").requiredOption("--task-id <taskId>", "Task ID to score").option("--complexity <level>", "Complexity level: low, medium, high").option("--value <level>", "Value level: low, medium, high").option("--priority <n>", "Priority number (higher = more important)").action(async (options) => {
+  await maybeRequireAuth();
+  const { scoreBacklog: scoreBacklog2 } = await Promise.resolve().then(() => (init_backlog(), exports_backlog));
+  await scoreBacklog2(options.chatroomId, options);
+});
 backlogCommand.command("reset-task").description("Reset a stuck in_progress task back to pending").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").requiredOption("--task-id <taskId>", "Task ID to reset").action(async (options) => {
   await maybeRequireAuth();
   const { resetBacklog: resetBacklog2 } = await Promise.resolve().then(() => (init_backlog(), exports_backlog));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatroom-cli",
-  "version": "1.0.71",
+  "version": "1.0.73",
   "description": "CLI for multi-agent chatroom collaboration",
   "type": "module",
   "bin": {