arcie 0.1.6 → 0.1.8

package/dist/agent/index.d.ts

@@ -1,6 +1 @@
-import { a as AgentConfig } from '../types-DwxwdSa2.js';
-import 'zod';
-
-declare function defineAgent(config: AgentConfig): AgentConfig;
-
-export { defineAgent };
+export { defineAgent_alias_1 as defineAgent } from '../_tsup-dts-rollup.js';

package/dist/auth/index.d.ts

@@ -1,11 +1,4 @@
-type TokenValue = string | (() => string | Promise<string>);
-type OutboundAuthFn = () => Promise<{
-    readonly headers: Readonly<Record<string, string>>;
-}>;
-declare function bearer(token: TokenValue): OutboundAuthFn;
-declare function basic(input: {
-    username: string;
-    password: TokenValue;
-}): OutboundAuthFn;
-
-export { type OutboundAuthFn, type TokenValue, basic, bearer };
+export { bearer_alias_1 as bearer } from '../_tsup-dts-rollup.js';
+export { basic_alias_1 as basic } from '../_tsup-dts-rollup.js';
+export { TokenValue_alias_1 as TokenValue } from '../_tsup-dts-rollup.js';
+export { OutboundAuthFn_alias_1 as OutboundAuthFn } from '../_tsup-dts-rollup.js';

package/dist/channels/index.d.ts

@@ -1,8 +1,3 @@
-import { d as ChannelConfig } from '../types-DwxwdSa2.js';
-import 'zod';
-
-declare function defineChannel(config: ChannelConfig): ChannelConfig;
-declare function POST(handler: ChannelConfig["handler"]): ChannelConfig["handler"];
-declare function GET(handler: ChannelConfig["handler"]): ChannelConfig["handler"];
-
-export { GET, POST, defineChannel };
+export { defineChannel_alias_1 as defineChannel } from '../_tsup-dts-rollup.js';
+export { POST_alias_1 as POST } from '../_tsup-dts-rollup.js';
+export { GET_alias_1 as GET } from '../_tsup-dts-rollup.js';

package/dist/cli/index.d.ts

@@ -1,8 +1 @@
-#!/usr/bin/env node
-interface CliLogger {
-    error(message: string): void;
-    log(message: string): void;
-}
-declare function runCli(argv?: string[], logger?: CliLogger): Promise<void>;
-
-export { runCli };
+export { runCli } from '../_tsup-dts-rollup.js';

package/dist/cli/index.js

@@ -105,7 +105,7 @@ function createCliProgram(logger) {
   });
   program.command("init [target]").description("Create a new arcie agent, or add one to an existing project directory.").option("--template <name>", "Template to use (default, agent-only)", "default").option("-y, --yes", "Accepted for compatibility; has no effect").action(async (target, options) => {
     if (options.yes) logger.error("warning: --yes has no effect for arcie init.");
-    const { initCommand } = await import("../init-5F7CIVLN.js");
+    const { initCommand } = await import("../init-Q2GCMBCJ.js");
     await initCommand(target, { template: options.template });
   });
   program.command("build").description("Compile the agent for production.").option("--agent-dir <path>", "Path to agent directory", "agent").option("--out-dir <path>", "Output directory", ".arcie").action(async (options) => {
@@ -140,7 +140,7 @@ function createCliProgram(logger) {
     "Model context window size, shown as a usage percentage",
     parseContextSizeOption
   ).option("--logs <mode>", "Which logs to show: all | stderr | none", parseLogsMode).action(async (options) => {
-    const { devCommand } = await import("../dev-ZZDVOWUZ.js");
+    const { devCommand } = await import("../dev-DCPOO54H.js");
     await devCommand({
       port: String(options.port ?? 3e3),
       agentDir: options.agentDir,

package/dist/context/index.d.ts

@@ -1,14 +1,9 @@
-import { j as Session, n as TurnContext } from '../types-DwxwdSa2.js';
-import 'zod';
-
-declare function getSession(): Session | null;
-declare function getTurn(): TurnContext | null;
-declare function setSession(session: Session): void;
-declare function setTurn(turn: TurnContext): void;
-declare function getContext<T = unknown>(key: string): T | undefined;
-declare function requireContext<T = unknown>(key: string): T;
-declare function hasContext(key: string): boolean;
-declare function setContext(key: string, value: unknown): void;
-declare function ensureContext<T>(key: string, factory: () => T): T;
-
-export { ensureContext, getContext, getSession, getTurn, hasContext, requireContext, setContext, setSession, setTurn };
+export { getSession_alias_1 as getSession } from '../_tsup-dts-rollup.js';
+export { getTurn_alias_1 as getTurn } from '../_tsup-dts-rollup.js';
+export { setSession_alias_1 as setSession } from '../_tsup-dts-rollup.js';
+export { setTurn_alias_1 as setTurn } from '../_tsup-dts-rollup.js';
+export { getContext_alias_1 as getContext } from '../_tsup-dts-rollup.js';
+export { requireContext_alias_1 as requireContext } from '../_tsup-dts-rollup.js';
+export { hasContext_alias_1 as hasContext } from '../_tsup-dts-rollup.js';
+export { setContext_alias_1 as setContext } from '../_tsup-dts-rollup.js';
+export { ensureContext_alias_1 as ensureContext } from '../_tsup-dts-rollup.js';

package/dist/{dev-ZZDVOWUZ.js → dev-DCPOO54H.js}

@@ -20,6 +20,9 @@ import {
 import {
   showHeader
 } from "./chunk-XOFWQUOO.js";
+import {
+  scaffoldWebChat
+} from "./chunk-SGWQZZ2A.js";
 import {
   streamAgent
 } from "./chunk-4WSILP75.js";
@@ -39,6 +42,89 @@ import { resolve } from "path";
 // src/cli/tui/renderer/start-block-chat.ts
 import { watch } from "fs";
 
+// src/cli/agent-config.ts
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
+import { join } from "path";
+function agentSourcePath(agentDir) {
+  return join(agentDir, "agent", "agent.ts");
+}
+function envLocalPath(agentDir) {
+  return join(agentDir, ".env.local");
+}
+function readAgentModel(agentDir) {
+  const path = agentSourcePath(agentDir);
+  if (!existsSync(path)) return void 0;
+  try {
+    const content = readFileSync(path, "utf-8");
+    return content.match(/model:\s*"([^"]+)"/)?.[1];
+  } catch {
+    return void 0;
+  }
+}
+function writeAgentModel(agentDir, model) {
+  const path = agentSourcePath(agentDir);
+  if (!existsSync(path)) return false;
+  const content = readFileSync(path, "utf-8");
+  const updated = content.replace(/model:\s*"[^"]+"/, `model: "${model}"`);
+  if (updated === content) return false;
+  writeFileSync(path, updated);
+  return true;
+}
+var PROVIDER_KEYS = [
+  "CENCORI_API_KEY",
+  "OPENAI_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "GROQ_API_KEY",
+  "DEEPSEEK_API_KEY",
+  "MISTRAL_API_KEY",
+  "GOOGLE_API_KEY",
+  "TOGETHER_API_KEY"
+];
+function providerKeyStatus(agentDir) {
+  const fileValues = readEnvLocal(agentDir);
+  return PROVIDER_KEYS.map((key) => {
+    const envValue = process.env[key];
+    if (envValue && envValue.length > 0) {
+      return { key, set: true, source: "env", masked: maskSecret(envValue) };
+    }
+    const fileValue = fileValues[key];
+    if (fileValue && fileValue.length > 0) {
+      return { key, set: true, source: "file", masked: maskSecret(fileValue) };
+    }
+    return { key, set: false };
+  });
+}
+function readEnvLocal(agentDir) {
+  const envPath = envLocalPath(agentDir);
+  if (!existsSync(envPath)) return {};
+  const values = {};
+  for (const line of readFileSync(envPath, "utf-8").split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#") || !trimmed.includes("=")) continue;
+    const eq = trimmed.indexOf("=");
+    const key = trimmed.slice(0, eq).trim();
+    const value = trimmed.slice(eq + 1).trim();
+    if (key && value) values[key] = value;
+  }
+  return values;
+}
+function listChannels(agentDir) {
+  const channelsDir = join(agentDir, "channels");
+  if (!existsSync(channelsDir)) return [];
+  try {
+    return readdirSync(channelsDir).filter((entry) => {
+      const full = join(channelsDir, entry);
+      return statSync(full).isDirectory();
+    }).map((name) => ({ name, path: join(channelsDir, name) }));
+  } catch {
+    return [];
+  }
+}
+function maskSecret(value) {
+  if (value.length <= 8) return "\u2022".repeat(value.length);
+  return `${value.slice(0, 4)}${"\u2022".repeat(6)}${value.slice(-4)}`;
+}
+
 // src/cli/tui/prompt-commands.ts
 var PROMPT_COMMAND_DEFINITIONS = [
   {
@@ -65,24 +151,25 @@ var PROMPT_COMMAND_DEFINITIONS = [
   {
     name: "model",
     aliases: [],
-    description: "Configure the agent's model and provider",
-    argumentHint: "[provider/model]",
+    description: "Show or change the agent's model",
+    argumentHint: "[provider/slug]",
     takesArgument: true,
     build: (argument) => ({ type: "extension", name: "model", argument })
   },
   {
     name: "provider",
     aliases: [],
-    description: "Configure provider API keys",
+    description: "Show provider API key status",
     takesArgument: false,
     build: () => ({ type: "extension", name: "provider", argument: "" })
   },
   {
     name: "channels",
     aliases: [],
-    description: "Add chat channels to the agent",
-    takesArgument: false,
-    build: () => ({ type: "extension", name: "channels", argument: "" })
+    description: "List or add chat channels",
+    argumentHint: "[add web]",
+    takesArgument: true,
+    build: (argument) => ({ type: "extension", name: "channels", argument })
   },
   {
     name: "loglevel",
@@ -1097,6 +1184,7 @@ var TerminalRenderer = class {
 };
 
 // src/cli/tui/renderer/start-block-chat.ts
+var VALID_LOG_MODES = /* @__PURE__ */ new Set(["all", "stderr", "none"]);
 async function startBlockChat(options) {
   const { agentDir } = options;
   const renderer = new TerminalRenderer();
@@ -1131,6 +1219,7 @@ async function startBlockChat(options) {
   } catch {
   }
   const detachKeys = attachKeyStream((key) => renderer.handleKey(key));
+  const logLevelState = { mode: "none" };
   try {
     if (options.initialInput !== void 0 && options.initialInput.length > 0) {
       await streamOneTurn(renderer, translator, agentDir, options.initialInput);
@@ -1160,10 +1249,10 @@ async function startBlockChat(options) {
             await commitHeader();
             continue;
           case "extension":
-            renderer.writeNotice(`/${command.name} not yet implemented`);
+            await handleExtension(command, renderer, agentDir, commitHeader);
             continue;
           case "loglevel":
-            renderer.writeNotice("logs not yet implemented");
+            handleLogLevel(command, renderer, logLevelState);
             continue;
         }
         continue;
@@ -1176,6 +1265,121 @@ async function startBlockChat(options) {
     renderer.stop();
   }
 }
+async function handleExtension(command, renderer, agentDir, commitHeader) {
+  const argument = command.argument.trim();
+  switch (command.name) {
+    case "model":
+      await handleModel(argument, renderer, agentDir, commitHeader);
+      return;
+    case "provider":
+      handleProvider(renderer, agentDir);
+      return;
+    case "channels":
+      handleChannels(argument, renderer, agentDir);
+      return;
+    default:
+      renderer.writeNotice(`/${command.name} is not supported here`);
+  }
+}
+async function handleModel(argument, renderer, agentDir, commitHeader) {
+  const current = readAgentModel(agentDir);
+  if (argument.length === 0) {
+    renderer.writeNotice(
+      current ? `current model: ${current}` : "no model configured in agent/agent.ts"
+    );
+    renderer.writeNotice("change it with: /model <provider/slug>");
+    return;
+  }
+  if (current === argument) {
+    renderer.writeNotice(`model is already ${argument}`);
+    return;
+  }
+  const changed = writeAgentModel(agentDir, argument);
+  if (!changed) {
+    renderer.writeError(
+      "Model not changed",
+      "Could not update agent/agent.ts \u2014 file missing or model field not found."
+    );
+    return;
+  }
+  renderer.writeNotice(`model set to ${argument}`);
+  await commitHeader();
+}
+function handleProvider(renderer, agentDir) {
+  const status = providerKeyStatus(agentDir);
+  const configured = status.filter((row) => row.set);
+  if (configured.length === 0) {
+    renderer.writeNotice("no provider keys configured");
+    renderer.writeNotice("edit .env.local to add CENCORI_API_KEY or a direct provider key");
+    return;
+  }
+  renderer.writeNotice("provider keys:");
+  for (const row of status) {
+    if (row.set) {
+      renderer.writeNotice(`  ${row.key} = ${row.masked} (${row.source})`);
+    } else {
+      renderer.writeNotice(`  ${row.key} \u2014 not set`);
+    }
+  }
+}
+function handleChannels(argument, renderer, agentDir) {
+  if (argument.length === 0) {
+    const channels = listChannels(agentDir);
+    if (channels.length === 0) {
+      renderer.writeNotice("no channels scaffolded");
+      renderer.writeNotice("add one with: /channels add web");
+      return;
+    }
+    renderer.writeNotice("channels:");
+    for (const channel of channels) renderer.writeNotice(`  ${channel.name} \u2014 ${channel.path}`);
+    renderer.writeNotice("add another with: /channels add <kind>");
+    return;
+  }
+  const parts = argument.split(/\s+/);
+  const subcommand = parts[0];
+  const kind = parts[1];
+  if (subcommand !== "add") {
+    renderer.writeError("Unknown /channels subcommand", `try: /channels add web`);
+    return;
+  }
+  if (kind !== "web") {
+    renderer.writeError("Unsupported channel kind", `${kind ?? "(none)"} \u2014 only 'web' is supported`);
+    return;
+  }
+  try {
+    const result = scaffoldWebChat(agentDir);
+    if (result.alreadyExisted) {
+      renderer.writeNotice(`channels/web already exists \u2014 left it untouched`);
+      return;
+    }
+    renderer.writeNotice(`scaffolded ${result.targetPath}`);
+    renderer.writeNotice("next: cd into it, npm install, npm run dev");
+  } catch (err) {
+    renderer.writeError(
+      "Channel scaffold failed",
+      err instanceof Error ? err.message : String(err)
+    );
+  }
+}
+function handleLogLevel(command, renderer, state) {
+  const argument = command.argument.trim();
+  if (argument.length === 0) {
+    renderer.writeNotice(`log level: ${state.mode}`);
+    renderer.writeNotice("change with: /loglevel all | stderr | none");
+    renderer.writeNotice("note: arcie does not currently capture subprocess logs.");
+    return;
+  }
+  if (!VALID_LOG_MODES.has(argument)) {
+    renderer.writeError(
+      "Invalid log level",
+      `${argument} \u2014 pick one of: all, stderr, none`
+    );
+    return;
+  }
+  state.mode = argument;
+  renderer.writeNotice(`log level: ${state.mode}`);
+  renderer.writeNotice("note: arcie does not currently capture subprocess logs.");
+}
 async function streamOneTurn(renderer, translator, agentDir, message) {
   let sawApproval = false;
   try {
@@ -1859,51 +2063,40 @@ function checkProviderKeys(modelId) {
   }
   return missing;
 }
-async function devCommand(options) {
-  const agentDirPath = resolve(process.cwd(), options.agentDir);
-  const port = parseInt(options.port, 10);
-  const localApiUrl = `http://127.0.0.1:${port}/v1`;
-  if (!process.env.CENCORI_API_KEY) {
-    process.env.CENCORI_API_KEY = "local-dev-key";
-  }
-  if (!process.env.CENCORI_API_URL) {
-    process.env.CENCORI_API_URL = localApiUrl;
-  }
-  if (!options.input) {
-    showHeader();
-    const { diagnostics } = discoverAgent(agentDirPath);
-    if (diagnostics.some((d) => d.severity === "error")) {
-      for (const d of diagnostics) {
-        console.error(`  ${grey("\u2716")} ${d.code}: ${d.message}`);
-      }
-      process.exit(1);
-    }
-    for (const d of diagnostics) {
-      console.warn(`  ${grey("\u26A0")} ${d.code}: ${d.message}`);
-    }
+var MAX_PORT_ATTEMPTS = 10;
+function tryListen(server, port) {
+  return new Promise((resolve2, reject) => {
+    const onError = (err) => {
+      server.removeListener("listening", onListening);
+      reject(err);
+    };
+    const onListening = () => {
+      server.removeListener("error", onError);
+      resolve2();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port);
+  });
+}
+async function listenWithFallback(server, startPort) {
+  for (let offset = 0; offset < MAX_PORT_ATTEMPTS; offset += 1) {
+    const port = startPort + offset;
     try {
-      const agent = await loadAgent(agentDirPath);
-      console.log(`  ${agentDirPath} ${grey("\xB7")} ${grey(agent.manifest.config.model)}`);
-      console.log();
-      console.log(`  ${dimmed(`http://localhost:${port}`)}`);
-      console.log();
-      console.log(`  ${dimmed(`$ curl -X POST http://localhost:${port} \\`)}`);
-      console.log(`  ${dimmed(`  -H "Content-Type: application/json" \\`)}`);
-      console.log(`  ${dimmed(`  -d '{"message": "hello"}'`)}`);
-      console.log();
-      const missing = checkProviderKeys(agent.manifest.config.model);
-      if (missing.length > 0) {
-        console.log(`  ${grey("\u26A0")} Missing API keys: ${missing.join(", ")}`);
-        console.log(`  ${dimmed("  Set them in .env.local or your environment")}`);
-        console.log();
-      }
-    } catch {
-      console.log(`  ${agentDirPath}`);
-      console.log();
-      console.log(`  ${dimmed(`http://localhost:${port}`)}`);
-      console.log();
+      await tryListen(server, port);
+      return port;
+    } catch (err) {
+      const code = err.code;
+      if (code !== "EADDRINUSE") throw err;
     }
   }
+  throw new Error(
+    `Could not find a free port in ${startPort}..${startPort + MAX_PORT_ATTEMPTS - 1}`
+  );
+}
+async function devCommand(options) {
+  const agentDirPath = resolve(process.cwd(), options.agentDir);
+  const requestedPort = parseInt(options.port, 10);
   const server = createServer(async (req, res) => {
     if (await handleSessionsRequest(req, res)) {
       return;
@@ -1938,30 +2131,65 @@ async function devCommand(options) {
       res.end("Not found");
     }
   });
-  server.on("error", (err) => {
-    if (err.code === "EADDRINUSE") {
-      console.error();
-      console.error(`  ${grey("\u2717")} port ${port} is already in use`);
-      console.error(`  ${dimmed(`try: arcie dev --port ${port + 1}`)}`);
-      console.error(`  ${dimmed(`or:  lsof -iTCP:${port} -sTCP:LISTEN -n -P    # find and kill the holder`)}`);
-      console.error();
-    } else {
-      console.error();
-      console.error(`  ${grey("\u2717")} ${err.message}`);
-      console.error();
-    }
+  let boundPort;
+  try {
+    boundPort = await listenWithFallback(server, requestedPort);
+  } catch (err) {
+    console.error();
+    console.error(`  ${grey("\u2717")} ${err instanceof Error ? err.message : String(err)}`);
+    console.error(`  ${dimmed("try: arcie dev --port <n>    # pick your own starting port")}`);
+    console.error();
     process.exit(1);
-  });
+  }
+  const localApiUrl = `http://127.0.0.1:${boundPort}/v1`;
+  if (!process.env.CENCORI_API_KEY) process.env.CENCORI_API_KEY = "local-dev-key";
+  if (!process.env.CENCORI_API_URL) process.env.CENCORI_API_URL = localApiUrl;
+  if (!options.input) {
+    showHeader();
+    const { diagnostics } = discoverAgent(agentDirPath);
+    if (diagnostics.some((d) => d.severity === "error")) {
+      for (const d of diagnostics) {
+        console.error(`  ${grey("\u2716")} ${d.code}: ${d.message}`);
+      }
+      process.exit(1);
+    }
+    for (const d of diagnostics) {
+      console.warn(`  ${grey("\u26A0")} ${d.code}: ${d.message}`);
+    }
+    try {
+      const agent = await loadAgent(agentDirPath);
+      console.log(`  ${agentDirPath} ${grey("\xB7")} ${grey(agent.manifest.config.model)}`);
+      console.log();
+      if (boundPort !== requestedPort) {
+        console.log(
+          `  ${grey("!")} port ${requestedPort} was in use ${grey("\xB7")} using ${boundPort}`
+        );
+        console.log();
+      }
+      console.log(`  ${dimmed(`http://localhost:${boundPort}`)}`);
+      console.log();
+      console.log(`  ${dimmed(`$ curl -X POST http://localhost:${boundPort} \\`)}`);
+      console.log(`  ${dimmed(`  -H "Content-Type: application/json" \\`)}`);
+      console.log(`  ${dimmed(`  -d '{"message": "hello"}'`)}`);
+      console.log();
+      const missing = checkProviderKeys(agent.manifest.config.model);
+      if (missing.length > 0) {
+        console.log(`  ${grey("\u26A0")} Missing API keys: ${missing.join(", ")}`);
+        console.log(`  ${dimmed("  Set them in .env.local or your environment")}`);
+        console.log();
+      }
+    } catch {
+      console.log(`  ${agentDirPath}`);
+      console.log();
+      console.log(`  ${dimmed(`http://localhost:${boundPort}`)}`);
+      console.log();
+    }
+  }
   if (options.input) {
-    server.listen(port, () => {
-      void startBlockChat({ agentDir: agentDirPath });
-    });
-  } else {
-    server.listen(port, () => {
-    });
+    void startBlockChat({ agentDir: agentDirPath });
   }
 }
 export {
   devCommand
 };
-//# sourceMappingURL=dev-ZZDVOWUZ.js.map
+//# sourceMappingURL=dev-DCPOO54H.js.map