@agent-play/cli 3.1.0 → 3.2.1

package/dist/cli.js

@@ -1,24 +1,263 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { existsSync } from "fs";
-import { mkdir, unlink, writeFile } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir2, unlink, writeFile as writeFile2 } from "fs/promises";
 import { homedir } from "os";
-import { join, resolve } from "path";
+import { join as join2, resolve as resolve2 } from "path";
 import { createInterface } from "readline/promises";
 import { stdin as input, stdout as output } from "process";
 import {
-  createNodeCredentialFromPassw,
-  deriveNodeIdFromPassword,
-  generateNodePassw,
-  hashNodePassword,
+  createNodeCredentialMaterial,
   loadAgentPlayCredentialsFileFromPath,
-  loadRootKey
+  loadRootKey,
+  nodeCredentialsMaterialFromHumanPassphrase
 } from "@agent-play/node-tools";
+
+// src/initialize.ts
+import { existsSync } from "fs";
+import { mkdir, readdir, readFile, writeFile } from "fs/promises";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+function resolveServerUrlForEnvironment(environment) {
+  if (environment === "test") {
+    return "https://test-agent-play.com";
+  }
+  if (environment === "production") {
+    return "https://agent-play.com";
+  }
+  return "http://127.0.0.1:3000";
+}
+var TEMPLATE_ROOT = fileURLToPath(
+  new URL("../templates/agent-starter/langchain", import.meta.url)
+);
+function parseInitializeArgs(argv) {
+  const out = {
+    template: "langchain",
+    yes: false,
+    force: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token === "--dir" && typeof argv[i + 1] === "string") {
+      out.dir = argv[++i];
+      continue;
+    }
+    if (token === "--name" && typeof argv[i + 1] === "string") {
+      out.name = argv[++i];
+      continue;
+    }
+    if (token === "--template" && typeof argv[i + 1] === "string") {
+      const template = argv[++i];
+      if (template !== "langchain") {
+        return null;
+      }
+      out.template = template;
+      continue;
+    }
+    if (token === "--yes") {
+      out.yes = true;
+      continue;
+    }
+    if (token === "--force") {
+      out.force = true;
+      continue;
+    }
+    if (token === "--bootstrap-nodes") {
+      out.bootstrapNodes = true;
+      continue;
+    }
+    if (token === "--agent-count" && typeof argv[i + 1] === "string") {
+      const raw = Number(argv[++i]);
+      if (raw !== 1 && raw !== 2) {
+        return null;
+      }
+      out.agentCount = raw;
+      continue;
+    }
+    if (token === "--environment" && typeof argv[i + 1] === "string") {
+      const value = argv[++i].trim().toLowerCase();
+      if (value === "development" || value === "test" || value === "production") {
+        out.environment = value;
+        continue;
+      }
+      return null;
+    }
+    if (token === "--server-type" && typeof argv[i + 1] === "string") {
+      const value = argv[++i].trim().toLowerCase();
+      if (value === "bare" || value === "express") {
+        out.serverType = value;
+        continue;
+      }
+      return null;
+    }
+    return null;
+  }
+  return out;
+}
+function normalizeProjectName(raw) {
+  if (typeof raw !== "string") {
+    return "agent-play-agent-starter";
+  }
+  const normalized = raw.trim().toLowerCase().replace(/[^a-z0-9-_]+/g, "-");
+  if (normalized.length === 0) {
+    return "agent-play-agent-starter";
+  }
+  return normalized;
+}
+async function listTemplateFiles(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await listTemplateFiles(full);
+      files.push(...nested.map((path) => join(entry.name, path)));
+      continue;
+    }
+    files.push(entry.name);
+  }
+  return files;
+}
+async function ensureSafeTarget(options) {
+  const targetExists = existsSync(options.targetDir);
+  if (!targetExists) {
+    await mkdir(options.targetDir, { recursive: true });
+    return;
+  }
+  if (options.force) {
+    return;
+  }
+  const existing = await readdir(options.targetDir);
+  if (existing.length > 0) {
+    throw new Error(
+      `Target directory is not empty: ${options.targetDir}. Re-run with --force to overwrite scaffold-managed files.`
+    );
+  }
+}
+function patchEnvContent(options) {
+  const lines = options.envContent.split(/\r?\n/);
+  const updates = /* @__PURE__ */ new Map([
+    ["AGENT_PLAY_WEB_UI_URL", options.serverUrl],
+    ["AGENT_PLAY_MAIN_NODE_ID", options.mainNodeId],
+    ["AGENT_PLAY_AGENT_NODE_ID_1", options.agentNodeIds[0] ?? ""],
+    ["AGENT_PLAY_AGENT_NODE_ID_2", options.agentNodeIds[1] ?? ""]
+  ]);
+  const seen = /* @__PURE__ */ new Set();
+  const next = lines.map((line) => {
+    const eqIndex = line.indexOf("=");
+    if (eqIndex <= 0) {
+      return line;
+    }
+    const key = line.slice(0, eqIndex);
+    const update = updates.get(key);
+    if (update === void 0) {
+      return line;
+    }
+    seen.add(key);
+    return `${key}=${update}`;
+  });
+  for (const [key, value] of updates.entries()) {
+    if (!seen.has(key)) {
+      next.push(`${key}=${value}`);
+    }
+  }
+  return next.join("\n");
+}
+async function renderTemplate(options) {
+  const files = await listTemplateFiles(TEMPLATE_ROOT);
+  for (const relativePath of files) {
+    const templatePath = join(TEMPLATE_ROOT, relativePath);
+    const targetPath = join(options.targetDir, relativePath);
+    if (!options.force && existsSync(targetPath)) {
+      continue;
+    }
+    await mkdir(dirname(targetPath), { recursive: true });
+    const source = await readFile(templatePath, "utf8");
+    const serverModule = options.serverType === "express" ? "./express-server.js" : "./bare-server.js";
+    const content = source.replaceAll("__PROJECT_NAME__", options.projectName).replaceAll("__AGENT_NAME__", "Starter Agent").replaceAll("__SERVER_MODULE__", serverModule);
+    await writeFile(targetPath, content, "utf8");
+  }
+}
+async function cmdInitialize(options) {
+  const parsed = parseInitializeArgs(options.argv);
+  if (parsed === null) {
+    throw new Error(
+      "Usage: agent-play initialize [--dir <path>] [--name <project-name>] [--template langchain] [--environment <development|test|production>] [--server-type <bare|express>] [--yes] [--force] [--bootstrap-nodes] [--agent-count <1|2>]"
+    );
+  }
+  const targetDir = resolve(parsed.dir ?? process.cwd());
+  const projectName = normalizeProjectName(parsed.name ?? basenameFromPath(targetDir));
+  const environment = parsed.environment ?? (parsed.yes ? "development" : await options.promptApi.askEnvironment());
+  const serverType = parsed.serverType ?? (parsed.yes ? "bare" : await options.promptApi.askServerType());
+  const serverUrl = resolveServerUrlForEnvironment(environment);
+  const agentCount = parsed.agentCount ?? (parsed.yes ? 1 : await options.promptApi.askAgentCount());
+  const bootstrapNodes = parsed.bootstrapNodes ?? (parsed.yes ? false : await options.promptApi.askBootstrapNodes());
+  await ensureSafeTarget({ targetDir, force: parsed.force });
+  await renderTemplate({
+    targetDir,
+    projectName,
+    serverType,
+    force: parsed.force
+  });
+  const envExamplePath = join(targetDir, ".env.example");
+  const envPath = join(targetDir, ".env");
+  if (!existsSync(envPath) && existsSync(envExamplePath)) {
+    await writeFile(envPath, await readFile(envExamplePath, "utf8"), "utf8");
+  }
+  if (bootstrapNodes) {
+    const bootstrapped = await options.runtimeApi.bootstrapNodeIds({
+      agentCount,
+      serverUrl
+    });
+    const envContent = existsSync(envPath) ? await readFile(envPath, "utf8") : "";
+    const nextEnv = patchEnvContent({
+      envContent,
+      serverUrl,
+      mainNodeId: bootstrapped.mainNodeId,
+      agentNodeIds: bootstrapped.agentNodeIds
+    });
+    await writeFile(envPath, nextEnv, "utf8");
+    console.log(`Bootstrapped main node id: ${bootstrapped.mainNodeId}`);
+    for (const [index, nodeId] of bootstrapped.agentNodeIds.entries()) {
+      console.log(`Bootstrapped agent node ${String(index + 1)} id: ${nodeId}`);
+    }
+  } else if (existsSync(envPath)) {
+    const envContent = await readFile(envPath, "utf8");
+    const nextEnv = patchEnvContent({
+      envContent,
+      serverUrl,
+      mainNodeId: "",
+      agentNodeIds: []
+    });
+    await writeFile(envPath, nextEnv, "utf8");
+  }
+  console.log("");
+  console.log("Agent starter scaffold created.");
+  console.log(`Location: ${targetDir}`);
+  console.log("Next steps:");
+  console.log(`  cd "${targetDir}"`);
+  console.log("  npm install");
+  if (!bootstrapNodes) {
+    console.log("  npx agent-play create-main-node");
+    console.log("  npx agent-play create-agent-node");
+    if (agentCount === 2) {
+      console.log("  npx agent-play create-agent-node");
+    }
+    console.log("  copy node ids into .env");
+  }
+  console.log("  npm run dev");
+}
+function basenameFromPath(pathValue) {
+  const split = pathValue.split(/[\\/]/).filter((part) => part.length > 0);
+  return split[split.length - 1] ?? "agent-play-agent-starter";
+}
+
+// src/cli.ts
 function nodeAuthHeaders(cred) {
   return {
     "x-node-id": cred.nodeId,
-    "x-node-passw": hashNodePassword(cred.passw)
+    "x-node-passw": nodeCredentialsMaterialFromHumanPassphrase(cred.passw)
   };
 }
 function parseAgentRows(agentsRaw) {
@@ -36,15 +275,15 @@ function parseAgentRows(agentsRaw) {
   return agents;
 }
 function credentialsPath() {
-  return join(homedir(), ".agent-play", "credentials.json");
+  return join2(homedir(), ".agent-play", "credentials.json");
 }
 async function loadCredentials() {
   return loadAgentPlayCredentialsFileFromPath(credentialsPath());
 }
 async function saveCredentials(c) {
-  const dir = join(homedir(), ".agent-play");
-  await mkdir(dir, { recursive: true });
-  await writeFile(
+  const dir = join2(homedir(), ".agent-play");
+  await mkdir2(dir, { recursive: true });
+  await writeFile2(
     credentialsPath(),
     JSON.stringify(c, null, 2),
     "utf8"
@@ -101,6 +340,102 @@ async function promptBootstrapEnvironment(rl) {
     );
   }
 }
+function parseInitializeBootstrapAnswer(raw) {
+  const trimmed = raw.trim().toLowerCase();
+  if (trimmed === "" || trimmed === "y" || trimmed === "yes") {
+    return true;
+  }
+  if (trimmed === "n" || trimmed === "no") {
+    return false;
+  }
+  return null;
+}
+async function promptInitializeBootstrapChoice(rl) {
+  for (; ; ) {
+    const answer = await rl.question("Create node identities now? [Y/n]: ");
+    const parsed = parseInitializeBootstrapAnswer(answer);
+    if (parsed !== null) {
+      return parsed;
+    }
+    console.log("Please answer yes or no.");
+  }
+}
+function parseInitializeAgentCount(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "" || trimmed === "1") {
+    return 1;
+  }
+  if (trimmed === "2") {
+    return 2;
+  }
+  return null;
+}
+async function promptInitializeAgentCount(rl) {
+  for (; ; ) {
+    const answer = await rl.question("How many agents do you want to deploy? (1-2) [1]: ");
+    const parsed = parseInitializeAgentCount(answer);
+    if (parsed !== null) {
+      return parsed;
+    }
+    console.log("Invalid value. Enter 1 or 2.");
+  }
+}
+function parseInitializeEnvironmentAnswer(raw) {
+  const trimmed = raw.trim().toLowerCase();
+  if (trimmed === "" || trimmed === "1" || trimmed === "development" || trimmed === "dev") {
+    return "development";
+  }
+  if (trimmed === "2" || trimmed === "test") {
+    return "test";
+  }
+  if (trimmed === "3" || trimmed === "production" || trimmed === "prod") {
+    return "production";
+  }
+  return null;
+}
+async function promptInitializeEnvironment(rl) {
+  const lines = [
+    "Choose environment for initialization:",
+    "  1) development \u2192 http://127.0.0.1:3000",
+    "  2) test        \u2192 https://test-agent-play.com",
+    "  3) production  \u2192 https://agent-play.com",
+    "Enter 1-3, or development/test/production [1]: "
+  ].join("\n");
+  for (; ; ) {
+    const answer = await rl.question(lines);
+    const parsed = parseInitializeEnvironmentAnswer(answer);
+    if (parsed !== null) {
+      return parsed;
+    }
+    console.log("Invalid choice. Enter 1, 2, 3, development, test, or production.");
+  }
+}
+function parseInitializeServerTypeAnswer(raw) {
+  const trimmed = raw.trim().toLowerCase();
+  if (trimmed === "" || trimmed === "1" || trimmed === "bare") {
+    return "bare";
+  }
+  if (trimmed === "2" || trimmed === "express") {
+    return "express";
+  }
+  return null;
+}
+async function promptInitializeServerType(rl) {
+  const lines = [
+    "Choose server runtime:",
+    "  1) bare    \u2192 simple process entrypoint (minimal)",
+    "  2) express \u2192 deployable HTTP server with /health endpoint",
+    "Enter 1-2, or bare/express [1]: "
+  ].join("\n");
+  for (; ; ) {
+    const answer = await rl.question(lines);
+    const parsed = parseInitializeServerTypeAnswer(answer);
+    if (parsed !== null) {
+      return parsed;
+    }
+    console.log("Invalid choice. Enter 1, 2, bare, or express.");
+  }
+}
 function parseBootstrapNodeArgs(argv) {
   const out = {};
   for (let i = 0; i < argv.length; i++) {
@@ -137,29 +472,29 @@ function parseValidateAgentNodeArgs(argv) {
 }
 function resolveAgentPlayRootPath(options) {
   if (typeof options.rootFilePath === "string" && options.rootFilePath.trim().length > 0) {
-    return resolve(options.rootFilePath.trim());
+    return resolve2(options.rootFilePath.trim());
   }
   const fromEnv = process.env.AGENT_PLAY_ROOT_FILE_PATH;
   if (typeof fromEnv === "string" && fromEnv.trim().length > 0) {
-    return resolve(fromEnv.trim());
+    return resolve2(fromEnv.trim());
   }
-  const homeRoot = join(homedir(), ".agent-play", ".root");
-  if (existsSync(homeRoot)) {
+  const homeRoot = join2(homedir(), ".agent-play", ".root");
+  if (existsSync2(homeRoot)) {
     return homeRoot;
   }
-  const cwdRoot = resolve(process.cwd(), ".root");
-  if (existsSync(cwdRoot)) {
+  const cwdRoot = resolve2(process.cwd(), ".root");
+  if (existsSync2(cwdRoot)) {
     return cwdRoot;
   }
   throw new Error(
     "Agent Play root key not found. Pass --root-file <path>, set AGENT_PLAY_ROOT_FILE_PATH, or place .root in ~/.agent-play/ or the project directory."
   );
 }
-async function registerNodeOnServer(serverUrl, passw, expectedNodeId) {
+async function registerNodeOnServer(serverUrl, nodeId, passwHash) {
   const res = await fetch(`${serverUrl}/api/nodes`, {
     method: "POST",
     headers: { "content-type": "application/json" },
-    body: JSON.stringify({ kind: "main", passw })
+    body: JSON.stringify({ kind: "main", nodeId, passwHash })
   });
   const text = await res.text();
   if (res.status === 409) {
@@ -182,9 +517,7 @@ async function registerNodeOnServer(serverUrl, passw, expectedNodeId) {
   if (typeof json.nodeId !== "string") {
     throw new Error("Invalid response from server.");
   }
-  if (json.nodeId !== expectedNodeId) {
-    console.log("json", json);
-    console.log("expectedNodeId", expectedNodeId);
+  if (json.nodeId !== nodeId) {
     throw new Error(
       "Server node id does not match local derivation; check root file and server configuration."
     );
@@ -198,22 +531,20 @@ async function cmdBootstrapNode(argv) {
   console.log(`Using server: ${serverUrl}`);
   const rootPath = resolveAgentPlayRootPath(opts);
   const rootKey = loadRootKey(rootPath);
-  const dir = join(homedir(), ".agent-play");
-  await mkdir(dir, { recursive: true });
-  const generatedPassw = generateNodePassw();
-  const hashedPassw = hashNodePassword(generatedPassw);
-  const credential = createNodeCredentialFromPassw({ passw: hashedPassw, rootKey });
-  await registerNodeOnServer(serverUrl, hashedPassw, credential.nodeId);
+  const dir = join2(homedir(), ".agent-play");
+  await mkdir2(dir, { recursive: true });
+  const credential = createNodeCredentialMaterial({ rootKey });
+  await registerNodeOnServer(serverUrl, credential.nodeId, credential.passwHash);
   await saveCredentials({
     serverUrl,
     nodeId: credential.nodeId,
-    passw: generatedPassw
+    passw: credential.phrase
   });
   console.log(
     `genesisNodeId (platform root key from .root; all main nodes derive under this): ${rootKey}`
   );
   console.log(`mainNodeId (your developer node): ${credential.nodeId}`);
-  console.log(`passw: ${generatedPassw}`);
+  console.log(`passw: ${credential.phrase}`);
   console.log("Keep this material safe. Losing it means losing access.");
 }
 async function cmdClearNodeCredentials() {
@@ -255,12 +586,7 @@ async function cmdCreateAgentNode() {
     return;
   }
   const rootKey = loadRootKey(resolveAgentPlayRootPath({}));
-  const agentPassw = generateNodePassw();
-  const hashedAgentPassw = hashNodePassword(agentPassw);
-  const agentNodeId = deriveNodeIdFromPassword({
-    password: hashedAgentPassw,
-    rootKey
-  });
+  const agentCredential = createNodeCredentialMaterial({ rootKey });
   const res = await fetch(`${cred.serverUrl}/api/nodes/agent-node`, {
     method: "POST",
     headers: {
@@ -270,8 +596,8 @@ async function cmdCreateAgentNode() {
     body: JSON.stringify({
       kind: "agent",
       parentNodeId: cred.nodeId,
-      agentNodeId,
-      agentNodePassw: hashedAgentPassw
+      agentNodeId: agentCredential.nodeId,
+      agentNodePasswHash: agentCredential.passwHash
     })
   });
   const text = await res.text();
@@ -292,7 +618,7 @@ async function cmdCreateAgentNode() {
     process.exitCode = 1;
     return;
   }
-  if (json.agentId !== agentNodeId) {
+  if (json.agentId !== agentCredential.nodeId) {
     console.error(
       "Server returned a different agent node id than the locally derived one."
     );
@@ -300,10 +626,10 @@ async function cmdCreateAgentNode() {
     return;
   }
   const nextAgentNodes = [
-    ...(cred.agentNodes ?? []).filter((n) => n.nodeId !== agentNodeId),
+    ...(cred.agentNodes ?? []).filter((n) => n.nodeId !== agentCredential.nodeId),
     {
-      nodeId: agentNodeId,
-      passw: agentPassw,
+      nodeId: agentCredential.nodeId,
+      passw: agentCredential.phrase,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     }
   ];
@@ -313,13 +639,67 @@ async function cmdCreateAgentNode() {
   });
   printAgentPlayIntegrationGuide();
   console.log(`Created agent node id: ${json.agentId}`);
-  console.log(`Agent node passw: ${agentPassw}`);
+  console.log(`Agent node passw: ${agentCredential.phrase}`);
   console.log(
     `Saved agent node credentials to ${credentialsPath()} (agentNodes).`
   );
   console.log("Keep this material safe. Losing it means losing access.");
   console.log("");
 }
+async function ensureMainCredentialsForInitialize(serverUrl) {
+  const existing = await loadCredentials();
+  if (existing !== null && existing.serverUrl.replace(/\/$/, "") === serverUrl.replace(/\/$/, "")) {
+    return existing;
+  }
+  const rootKey = loadRootKey(resolveAgentPlayRootPath({}));
+  const credential = createNodeCredentialMaterial({ rootKey });
+  await registerNodeOnServer(serverUrl, credential.nodeId, credential.passwHash);
+  const created = {
+    serverUrl,
+    nodeId: credential.nodeId,
+    passw: credential.phrase
+  };
+  await saveCredentials(created);
+  return created;
+}
+async function createAgentNodeForInitialize(cred) {
+  const rootKey = loadRootKey(resolveAgentPlayRootPath({}));
+  const agentCredential = createNodeCredentialMaterial({ rootKey });
+  const res = await fetch(`${cred.serverUrl}/api/nodes/agent-node`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...nodeAuthHeaders(cred)
+    },
+    body: JSON.stringify({
+      kind: "agent",
+      parentNodeId: cred.nodeId,
+      agentNodeId: agentCredential.nodeId,
+      agentNodePasswHash: agentCredential.passwHash
+    })
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(`Create failed (${String(res.status)}): ${text}`);
+  }
+  const json = JSON.parse(text);
+  if (typeof json.agentId !== "string" || json.agentId !== agentCredential.nodeId) {
+    throw new Error("Invalid agent creation response.");
+  }
+  const nextAgentNodes = [
+    ...(cred.agentNodes ?? []).filter((n) => n.nodeId !== agentCredential.nodeId),
+    {
+      nodeId: agentCredential.nodeId,
+      passw: agentCredential.phrase,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  ];
+  await saveCredentials({
+    ...cred,
+    agentNodes: nextAgentNodes
+  });
+  return agentCredential.nodeId;
+}
 async function cmdInspectNode() {
   const cred = await loadCredentials();
   if (cred === null) {
@@ -642,6 +1022,37 @@ async function cmdValidateAgentNode(argv) {
   }
   console.log(`Validated ${String(dedupedIds.length)} agent node(s) successfully.`);
 }
+async function cmdInitialize2(argv) {
+  const rl = createInterface({ input, output });
+  try {
+    await cmdInitialize({
+      argv,
+      promptApi: {
+        askEnvironment: () => promptInitializeEnvironment(rl),
+        askServerType: () => promptInitializeServerType(rl),
+        askBootstrapNodes: () => promptInitializeBootstrapChoice(rl),
+        askAgentCount: () => promptInitializeAgentCount(rl)
+      },
+      runtimeApi: {
+        bootstrapNodeIds: async (options) => {
+          const mainCred = await ensureMainCredentialsForInitialize(options.serverUrl);
+          const agentNodeIds = [];
+          for (let i = 0; i < options.agentCount; i++) {
+            const refreshedCred = await loadCredentials() ?? mainCred;
+            const nodeId = await createAgentNodeForInitialize(refreshedCred);
+            agentNodeIds.push(nodeId);
+          }
+          return {
+            mainNodeId: mainCred.nodeId,
+            agentNodeIds
+          };
+        }
+      }
+    });
+  } finally {
+    rl.close();
+  }
+}
 async function main() {
   const cmd = process.argv[2];
   if (cmd === "bootstrap-node" || cmd === "create-main-node") {
@@ -680,6 +1091,10 @@ async function main() {
     await cmdValidateAgentNode(process.argv.slice(3));
     return;
   }
+  if (cmd === "initialize" || cmd === "init") {
+    await cmdInitialize2(process.argv.slice(3));
+    return;
+  }
   console.error(
     [
       "Usage:",
@@ -692,6 +1107,7 @@ async function main() {
       "  agent-play validate-main-node",
       "  agent-play validate-agent-node --all",
       "  agent-play validate-agent-node --agent-node-ids <id1,id2,...>",
+      "  agent-play initialize | init [--dir <path>] [--name <project-name>] [--template langchain] [--environment <development|test|production>] [--server-type <bare|express>] [--yes] [--force] [--bootstrap-nodes] [--agent-count <1|2>]",
       "  agent-play clear-node-credentials"
     ].join("\n")
   );

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agent-play/cli",
-  "version": "3.1.0",
-  "description": "Command-line tool for Agent Play: login, API keys, and agent registration against the web UI.",
+  "version": "3.2.1",
+  "description": "Command-line tool for Agent Play: node configurations, agent starter kit, and agent registration against the web UI.",
   "private": false,
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   },
   "files": [
     "dist",
+    "templates",
     "README.md"
   ],
   "repository": {
@@ -20,7 +21,9 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsup src/cli.ts --format esm --platform node --target node20 --out-dir dist --clean --external @agent-play/node-tools && node ../../scripts/copy-root-file.mjs cli"
+    "build": "tsup src/cli.ts --format esm --platform node --target node20 --out-dir dist --clean --external @agent-play/node-tools && node ../../scripts/copy-root-file.mjs cli && cp README.md dist/README.md",
+    "test": "vitest run",
+    "smoke:initialize": "node ./scripts/smoke-initialize.mjs"
   },
   "dependencies": {
     "@agent-play/node-tools": "1.0.0"
@@ -28,6 +31,7 @@
   "devDependencies": {
     "@types/node": "^22.10.0",
     "tsup": "^8.5.1",
-    "typescript": "~5.9.3"
+    "typescript": "~5.9.3",
+    "vitest": "^4.1.1"
   }
 }

package/templates/agent-starter/langchain/.env.example

@@ -0,0 +1,6 @@
+AGENT_PLAY_WEB_UI_URL=https://agent-play.com
+AGENT_PLAY_MAIN_NODE_ID=
+AGENT_PLAY_AGENT_NODE_ID_1=
+AGENT_PLAY_AGENT_NODE_ID_2=
+OPENAI_API_KEY=
+P2A_WEBRTC_ENABLED=1