@corvio/admin-cli 0.1.0-beta.7 → 0.1.0-beta.8

package/dist/cli.js

@@ -24,7 +24,7 @@ import {
   writeResult,
 } from "./core.js";
 
-const VERSION = "0.1.0-beta.7";
+const VERSION = "0.1.0-beta.8";
 const DEFAULT_API_BASE = "https://api.corvio.ai/v1";
 const USER_AGENT = `corvio-admin-cli/${VERSION}`;
 const GLOBAL_OPTIONS = Object.freeze(["api-base", "json", "no-input", "help", "version"]);

package/dist/core.js

@@ -97,6 +97,8 @@ export function parseArgv(argv) {
     "force",
     "once",
     "include-revoked",
+    "recover-credential",
+    "no-listen",
     "start-new-chain",
     "help",
     "version",
@@ -556,6 +558,14 @@ export function adminCredentialPath(env = process.env) {
   return join(configRoot(env), "admin-credentials.json");
 }
 
+export function agentCredentialPath(env = process.env) {
+  return join(configRoot(env), "agent-credentials.json");
+}
+
+export function conversationRoutingPath(env = process.env) {
+  return join(configRoot(env), "conversation-routing.json");
+}
+
 export async function readWorkspaceCredential(env = process.env) {
   const environmentKey = String(env.CORVIO_API_KEY || "").trim();
   if (environmentKey) {
@@ -588,21 +598,72 @@ export async function readWorkspaceCredential(env = process.env) {
   return { key, source: "device_link", profile: profileName, metadata };
 }
 
-export function readAgentCredential(env = process.env) {
+export async function readAgentCredential(env = process.env, { required = true } = {}) {
   const key = String(env.CORVIO_AGENT_API_KEY || "").trim();
-  if (!key) {
+  if (key) {
+    if (!key.startsWith("cvg_")) {
+      throw new CliError("CORVIO_AGENT_API_KEY must be an Agent cvg_ key.", {
+        code: "invalid_agent_key",
+        exitCode: EXIT.AUTH,
+      });
+    }
+    return { key, source: "environment", profile: null, metadata: null };
+  }
+  const path = agentCredentialPath(env);
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(path, "utf8"));
+  } catch (cause) {
+    if (cause?.code === "ENOENT" && !required) return null;
+    if (cause?.code === "ENOENT") {
+      throw new CliError(
+        "No Agent credential found. Run `corvio agents connect` or set CORVIO_AGENT_API_KEY.",
+        { code: "agent_auth_required", exitCode: EXIT.AUTH },
+      );
+    }
+    throw new CliError("Stored Agent credentials are unreadable.", {
+      code: "agent_credential_store_invalid",
+      exitCode: EXIT.AUTH,
+    });
+  }
+  const storedKey = String(parsed?.api_key || "").trim();
+  if (!storedKey.startsWith("cvg_")) {
     throw new CliError(
-      "No Agent credential found. Set CORVIO_AGENT_API_KEY to the cvg_ secret returned when the Agent was created.",
-      { code: "agent_auth_required", exitCode: EXIT.AUTH },
+      "Stored Agent credentials are invalid; run `corvio agents connect --recover-credential`.",
+      { code: "agent_credential_store_invalid", exitCode: EXIT.AUTH },
     );
   }
-  if (!key.startsWith("cvg_")) {
-    throw new CliError("CORVIO_AGENT_API_KEY must be an Agent cvg_ key.", {
-      code: "invalid_agent_key",
+  return { key: storedKey, source: "secure_store", profile: "default", metadata: parsed };
+}
+
+export async function storeAgentCredential(payload, env = process.env) {
+  const secret = String(payload?.secret || "").trim();
+  if (!secret.startsWith("cvg_")) {
+    throw new CliError("Agent connection did not return a valid cvg_ credential.", {
+      code: "agent_credential_invalid",
       exitCode: EXIT.AUTH,
     });
   }
-  return { key, source: "environment", profile: null, metadata: null };
+  const path = agentCredentialPath(env);
+  const root = dirname(path);
+  await mkdir(root, { recursive: true, mode: 0o700 });
+  await chmod(root, 0o700).catch(() => {});
+  const document = {
+    version: 1,
+    api_key: secret,
+    agent_id: String(payload.agent_id || ""),
+    display_name: String(payload.display_name || ""),
+    provider: String(payload.provider || "custom"),
+    display_prefix: String(payload.display_prefix || "cvg"),
+    created_at: payload.created_at || new Date().toISOString(),
+    source: "agent_connect",
+  };
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(document, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+  await chmod(temporary, 0o600);
+  await rename(temporary, path);
+  await chmod(path, 0o600);
+  return { path, profile: "default", metadata: document };
 }
 
 export async function storeWorkspaceCredential(payload, env = process.env) {
@@ -642,6 +703,7 @@ export async function readWorkspaceContext(env = process.env) {
       workspaceId,
       workspaceName: String(parsed.active_workspace_name || "").trim() || null,
       source: "stored",
+      routingPreference: parsed.routing_preference || null,
     };
   } catch (cause) {
     if (cause?.code === "ENOENT") return null;
@@ -652,7 +714,7 @@ export async function readWorkspaceContext(env = process.env) {
   }
 }
 
-export async function storeWorkspaceContext({ workspaceId, workspaceName = null }, env = process.env) {
+export async function storeWorkspaceContext({ workspaceId, workspaceName = null, routingPreference = null }, env = process.env) {
   const normalizedId = String(workspaceId || "").trim();
   if (!normalizedId) throw new CliError("Workspace ID is required.", { code: "workspace_selection_required" });
   const path = workspaceContextPath(env);
@@ -663,6 +725,13 @@ export async function storeWorkspaceContext({ workspaceId, workspaceName = null
     version: 1,
     active_workspace_id: normalizedId,
     active_workspace_name: String(workspaceName || "").trim() || null,
+    routing_preference: routingPreference || {
+      workspace_id: normalizedId,
+      provenance: "user_confirmed_cli",
+      confidence: 1,
+      scope: "global",
+      expires_at: null,
+    },
     updated_at: new Date().toISOString(),
   };
   const temporary = `${path}.${randomUUID()}.tmp`;
@@ -673,6 +742,75 @@ export async function storeWorkspaceContext({ workspaceId, workspaceName = null
   return { path, workspaceId: normalizedId };
 }
 
+export async function readConversationRoutingReceipt(conversationId, env = process.env) {
+  const normalizedId = String(conversationId || "").trim();
+  if (!normalizedId) return null;
+  const path = conversationRoutingPath(env);
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    const receipt = parsed?.receipts?.[normalizedId];
+    const workspaceId = String(receipt?.workspace_id || "").trim();
+    if (!workspaceId) return null;
+    return {
+      conversationId: normalizedId,
+      workspaceId,
+      agentId: String(receipt.agent_id || "").trim() || null,
+      apiBase: String(receipt.api_base || "").trim() || null,
+      recordedAt: String(receipt.recorded_at || "").trim() || null,
+    };
+  } catch (cause) {
+    if (cause?.code === "ENOENT") return null;
+    throw new CliError("Stored Corvio conversation routing receipts are unreadable.", {
+      code: "conversation_routing_store_invalid",
+      exitCode: EXIT.AUTH,
+    });
+  }
+}
+
+export async function storeConversationRoutingReceipt({ conversationId, workspaceId, agentId = null, apiBase = null }, env = process.env) {
+  const normalizedConversationId = String(conversationId || "").trim();
+  const normalizedWorkspaceId = String(workspaceId || "").trim();
+  if (!normalizedConversationId || !normalizedWorkspaceId) {
+    throw new CliError("Conversation and Workspace IDs are required for routing continuity.", {
+      code: "conversation_routing_receipt_invalid",
+    });
+  }
+  const path = conversationRoutingPath(env);
+  const root = dirname(path);
+  await mkdir(root, { recursive: true, mode: 0o700 });
+  await chmod(root, 0o700).catch(() => {});
+  let existing = {};
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    if (parsed?.receipts && typeof parsed.receipts === "object" && !Array.isArray(parsed.receipts)) {
+      existing = parsed.receipts;
+    }
+  } catch (cause) {
+    if (cause?.code !== "ENOENT") {
+      throw new CliError("Stored Corvio conversation routing receipts are unreadable.", {
+        code: "conversation_routing_store_invalid",
+        exitCode: EXIT.AUTH,
+      });
+    }
+  }
+  const ordered = Object.entries({
+    ...existing,
+    [normalizedConversationId]: {
+      workspace_id: normalizedWorkspaceId,
+      agent_id: String(agentId || "").trim() || null,
+      api_base: String(apiBase || "").trim() || null,
+      recorded_at: new Date().toISOString(),
+    },
+  }).sort((left, right) => String(right[1]?.recorded_at || "").localeCompare(String(left[1]?.recorded_at || "")));
+  const document = { version: 1, receipts: Object.fromEntries(ordered.slice(0, 500)) };
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(document, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+  await chmod(temporary, 0o600);
+  await rename(temporary, path);
+  await chmod(path, 0o600);
+  return { path, conversationId: normalizedConversationId, workspaceId: normalizedWorkspaceId };
+}
+
 export async function clearWorkspaceContext(env = process.env) {
   const path = workspaceContextPath(env);
   await rm(path, { force: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@corvio/admin-cli",
-  "version": "0.1.0-beta.7",
+  "version": "0.1.0-beta.8",
   "description": "Official read-only Corvio platform administrator CLI.",
   "type": "module",
   "bin": {