volute 0.9.0 → 0.10.1

package/dist/delete-BOTVU4YO.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import {
+  resolveAgentName
+} from "./chunk-AZEL2IEK.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import "./chunk-K3NQKI34.js";
+
+// src/commands/delete.ts
+async function run(args) {
+  const { positional, flags } = parseArgs(args, {
+    force: { type: "boolean" }
+  });
+  const name = resolveAgentName({ agent: positional[0] });
+  const { daemonFetch } = await import("./daemon-client-P44NU3KU.js");
+  const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
+  const client = getClient();
+  const url = urlOf(client.api.agents[":name"].$url({ param: { name } })) + (flags.force ? "?force=true" : "");
+  const res = await daemonFetch(url, { method: "DELETE" });
+  const data = await res.json();
+  if (!res.ok) {
+    console.error(data.error ?? "Failed to delete agent");
+    process.exit(1);
+  }
+  console.log(`Removed ${name}.`);
+  if (flags.force) {
+    console.log("Deleted agent directory.");
+  } else {
+    console.log("Use --force to also delete the agent directory.");
+  }
+}
+export {
+  run
+};

package/dist/{down-4DGRZRJU.js → down-4LIQG3CE.js}

@@ -2,8 +2,10 @@
 import {
   run,
   stopDaemon
-} from "./chunk-YNNK4QN2.js";
+} from "./chunk-FYQGANL6.js";
+import "./chunk-STOEJOJO.js";
 import "./chunk-DP2DX4WV.js";
+import "./chunk-4RQBJWQX.js";
 import "./chunk-K3NQKI34.js";
 export {
   run,

package/dist/import-2BZUWT23.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import {
+  findOpenClawSession,
+  importOpenClawConnectors,
+  importPiSession,
+  parseNameFromIdentity,
+  run,
+  sessionMatchesWorkspace
+} from "./chunk-R3VB7NF5.js";
+import "./chunk-QF22MYDJ.js";
+import "./chunk-D424ZQGI.js";
+import "./chunk-DP2DX4WV.js";
+import "./chunk-K3NQKI34.js";
+export {
+  findOpenClawSession,
+  importOpenClawConnectors,
+  importPiSession,
+  parseNameFromIdentity,
+  run,
+  sessionMatchesWorkspace
+};

package/dist/{package-WPX6LCYE.js → package-TNE337RE.js}

@@ -4,7 +4,7 @@ import "./chunk-K3NQKI34.js";
 // package.json
 var package_default = {
   name: "volute",
-  version: "0.9.0",
+  version: "0.10.1",
   description: "CLI for creating and managing self-modifying AI agents powered by the Claude Agent SDK",
   type: "module",
   license: "MIT",

package/dist/{setup-7SPMWF2O.js → setup-6QFIHXSH.js}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
-import {
-  parseArgs
-} from "./chunk-D424ZQGI.js";
 import {
   ensureVoluteGroup
-} from "./chunk-IQXBMFZG.js";
+} from "./chunk-46S7YHUB.js";
 import {
   resolveVoluteBin
 } from "./chunk-5C5JWR2L.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
 import "./chunk-DP2DX4WV.js";
 import "./chunk-K3NQKI34.js";
 
@@ -62,7 +62,7 @@ function generateUnit(voluteBin, port, host) {
     "Restart=on-failure",
     "RestartSec=5",
     "ProtectSystem=strict",
-    `ReadWritePaths=${DATA_DIR} ${AGENTS_DIR}`,
+    `ReadWritePaths=${DATA_DIR} ${AGENTS_DIR} /etc`,
     "PrivateTmp=yes"
   ];
   if (!binUnderHome) {

package/dist/{up-J7AHQHIM.js → up-FCYL2IPZ.js}

@@ -2,7 +2,7 @@
 import {
   readGlobalConfig,
   run
-} from "./chunk-AWHQZDB4.js";
+} from "./chunk-M5AEQLB3.js";
 import "./chunk-D424ZQGI.js";
 import "./chunk-DP2DX4WV.js";
 import "./chunk-K3NQKI34.js";

package/dist/upgrade-RSE4CZNE.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import {
+  resolveAgentName
+} from "./chunk-AZEL2IEK.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import "./chunk-K3NQKI34.js";
+
+// src/commands/upgrade.ts
+async function run(args) {
+  const { positional, flags } = parseArgs(args, {
+    template: { type: "string" },
+    continue: { type: "boolean" }
+  });
+  const agentName = resolveAgentName({ agent: positional[0] });
+  const { daemonFetch } = await import("./daemon-client-P44NU3KU.js");
+  const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
+  const client = getClient();
+  const res = await daemonFetch(
+    urlOf(client.api.agents[":name"].upgrade.$url({ param: { name: agentName } })),
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        template: flags.template,
+        continue: flags.continue
+      })
+    }
+  );
+  const data = await res.json();
+  if (!res.ok && !data.conflicts) {
+    console.error(data.error ?? "Failed to upgrade agent");
+    process.exit(1);
+  }
+  if (data.conflicts) {
+    console.log("\nMerge conflicts detected. Resolve them in:");
+    console.log(`  ${data.worktreeDir}`);
+    console.log(`
+Then run:`);
+    console.log(`  volute agent upgrade ${agentName} --continue`);
+    return;
+  }
+  console.log(`
+Upgrade variant running on port ${data.port}`);
+  console.log(`
+Next steps:`);
+  console.log(
+    `  volute send @${agentName}@${data.variant} "hello"    # chat with upgraded variant`
+  );
+  console.log(`  volute variant merge ${data.variant}                # merge back when satisfied`);
+}
+export {
+  run
+};

package/dist/variant-7IZF6OWO.js

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+import {
+  resolveAgentName
+} from "./chunk-AZEL2IEK.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  checkHealth,
+  readVariants,
+  resolveAgent,
+  writeVariants
+} from "./chunk-DP2DX4WV.js";
+import "./chunk-K3NQKI34.js";
+
+// src/commands/variant.ts
+async function run(args) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "create":
+      await createVariant(args.slice(1));
+      break;
+    case "list":
+      await listVariants(args.slice(1));
+      break;
+    case "merge":
+      await mergeVariant(args.slice(1));
+      break;
+    case "delete":
+      await deleteVariant(args.slice(1));
+      break;
+    case "--help":
+    case "-h":
+    case void 0:
+      printUsage();
+      break;
+    default:
+      printUsage();
+      process.exit(1);
+  }
+}
+function printUsage() {
+  console.log(`Usage:
+  volute variant create <variant> [--agent <name>] [--soul "..."] [--port N] [--no-start] [--json]
+  volute variant list [--agent <name>] [--json]
+  volute variant merge <variant> [--agent <name>] [--summary "..." --memory "..."] [--skip-verify]
+  volute variant delete <variant> [--agent <name>]`);
+}
+async function createVariant(args) {
+  const { positional, flags } = parseArgs(args, {
+    agent: { type: "string" },
+    soul: { type: "string" },
+    port: { type: "number" },
+    "no-start": { type: "boolean" },
+    json: { type: "boolean" }
+  });
+  const agentName = resolveAgentName(flags);
+  const variantName = positional[0];
+  const { soul, port, json } = flags;
+  const noStart = flags["no-start"];
+  if (!variantName) {
+    console.error(
+      'Usage: volute variant create <variant> [--agent <name>] [--soul "..."] [--port N] [--no-start] [--json]'
+    );
+    process.exit(1);
+  }
+  if (!json) console.log("Creating variant via daemon...");
+  const { daemonFetch } = await import("./daemon-client-P44NU3KU.js");
+  const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
+  const client = getClient();
+  const res = await daemonFetch(
+    urlOf(client.api.agents[":name"].variants.$url({ param: { name: agentName } })),
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        name: variantName,
+        ...soul && { soul },
+        ...port && { port },
+        ...noStart && { noStart }
+      })
+    }
+  );
+  const data = await res.json();
+  if (!res.ok) {
+    console.error(data.error ?? "Failed to create variant");
+    process.exit(1);
+  }
+  if (json) {
+    console.log(JSON.stringify(data.variant, null, 2));
+  } else {
+    console.log(`
+Variant created: ${variantName}`);
+    console.log(`  Branch: ${data.variant?.branch}`);
+    console.log(`  Path:   ${data.variant?.path}`);
+    console.log(`  Port:   ${data.variant?.port}`);
+  }
+}
+async function listVariants(args) {
+  const { flags } = parseArgs(args, {
+    agent: { type: "string" },
+    json: { type: "boolean" }
+  });
+  const agentName = resolveAgentName(flags);
+  const { json } = flags;
+  resolveAgent(agentName);
+  const variants = readVariants(agentName);
+  if (variants.length === 0) {
+    if (json) {
+      console.log("[]");
+    } else {
+      console.log("No variants.");
+    }
+    return;
+  }
+  const results = await Promise.all(
+    variants.map(async (v) => {
+      if (!v.port) return { ...v, status: "no-server" };
+      const health = await checkHealth(v.port);
+      return { ...v, status: health.ok ? "running" : "dead" };
+    })
+  );
+  const updated = results.map(({ status, ...v }) => ({
+    ...v,
+    running: status === "running"
+  }));
+  writeVariants(agentName, updated);
+  if (json) {
+    console.log(JSON.stringify(results, null, 2));
+    return;
+  }
+  const nameW = Math.max(4, ...results.map((r) => r.name.length));
+  const portW = Math.max(4, ...results.map((r) => String(r.port || "-").length));
+  console.log(`${"NAME".padEnd(nameW)}  ${"PORT".padEnd(portW)}  ${"STATUS".padEnd(10)}  BRANCH`);
+  for (const r of results) {
+    console.log(
+      `${r.name.padEnd(nameW)}  ${String(r.port || "-").padEnd(portW)}  ${r.status.padEnd(10)}  ${r.branch}`
+    );
+  }
+}
+async function mergeVariant(args) {
+  const { positional, flags } = parseArgs(args, {
+    agent: { type: "string" },
+    summary: { type: "string" },
+    justification: { type: "string" },
+    memory: { type: "string" },
+    "skip-verify": { type: "boolean" }
+  });
+  const agentName = resolveAgentName(flags);
+  const variantName = positional[0];
+  if (!variantName) {
+    console.error(
+      "Usage: volute variant merge <variant> [--agent <name>] [--summary '...'] [--justification '...'] [--memory '...'] [--skip-verify]"
+    );
+    process.exit(1);
+  }
+  console.log(`Merging variant ${variantName}...`);
+  const { daemonFetch } = await import("./daemon-client-P44NU3KU.js");
+  const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
+  const client = getClient();
+  const res = await daemonFetch(
+    urlOf(
+      client.api.agents[":name"].variants[":variant"].merge.$url({
+        param: { name: agentName, variant: variantName }
+      })
+    ),
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        ...flags.summary && { summary: flags.summary },
+        ...flags.justification && { justification: flags.justification },
+        ...flags.memory && { memory: flags.memory },
+        ...flags["skip-verify"] && { skipVerify: true }
+      })
+    }
+  );
+  const data = await res.json();
+  if (!res.ok) {
+    console.error(data.error ?? "Failed to merge variant");
+    process.exit(1);
+  }
+  console.log(`Variant ${variantName} merged and cleaned up.`);
+}
+async function deleteVariant(args) {
+  const { positional, flags } = parseArgs(args, {
+    agent: { type: "string" }
+  });
+  const agentName = resolveAgentName(flags);
+  const variantName = positional[0];
+  if (!variantName) {
+    console.error("Usage: volute variant delete <variant> [--agent <name>]");
+    process.exit(1);
+  }
+  const { daemonFetch } = await import("./daemon-client-P44NU3KU.js");
+  const { getClient, urlOf } = await import("./api-client-YPKOZP2O.js");
+  const client = getClient();
+  const res = await daemonFetch(
+    urlOf(
+      client.api.agents[":name"].variants[":variant"].$url({
+        param: { name: agentName, variant: variantName }
+      })
+    ),
+    { method: "DELETE" }
+  );
+  const data = await res.json();
+  if (!res.ok) {
+    console.error(data.error ?? "Failed to delete variant");
+    process.exit(1);
+  }
+  console.log(`Variant ${variantName} deleted.`);
+}
+export {
+  run
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "volute",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "description": "CLI for creating and managing self-modifying AI agents powered by the Claude Agent SDK",
   "type": "module",
   "license": "MIT",

package/dist/chunk-ECPQXRLB.js

@@ -1,264 +0,0 @@
-#!/usr/bin/env node
-import {
-  voluteHome
-} from "./chunk-DP2DX4WV.js";
-import {
-  __export
-} from "./chunk-K3NQKI34.js";
-
-// src/lib/auth.ts
-import { compareSync, hashSync } from "bcryptjs";
-import { and, count, eq } from "drizzle-orm";
-
-// src/lib/db.ts
-import { chmodSync, existsSync } from "fs";
-import { dirname, resolve } from "path";
-import { fileURLToPath } from "url";
-import { drizzle } from "drizzle-orm/libsql";
-import { migrate } from "drizzle-orm/libsql/migrator";
-
-// src/lib/schema.ts
-var schema_exports = {};
-__export(schema_exports, {
-  agentMessages: () => agentMessages,
-  conversationParticipants: () => conversationParticipants,
-  conversations: () => conversations,
-  messages: () => messages,
-  sessions: () => sessions,
-  users: () => users
-});
-import { sql } from "drizzle-orm";
-import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
-var users = sqliteTable("users", {
-  id: integer("id").primaryKey({ autoIncrement: true }),
-  username: text("username").unique().notNull(),
-  password_hash: text("password_hash").notNull(),
-  role: text("role").notNull().default("pending"),
-  user_type: text("user_type").notNull().default("human"),
-  created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
-});
-var conversations = sqliteTable(
-  "conversations",
-  {
-    id: text("id").primaryKey(),
-    agent_name: text("agent_name").notNull(),
-    channel: text("channel").notNull(),
-    user_id: integer("user_id").references(() => users.id),
-    title: text("title"),
-    created_at: text("created_at").notNull().default(sql`(datetime('now'))`),
-    updated_at: text("updated_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [
-    index("idx_conversations_agent_name").on(table.agent_name),
-    index("idx_conversations_user_id").on(table.user_id),
-    index("idx_conversations_updated_at").on(table.updated_at)
-  ]
-);
-var agentMessages = sqliteTable(
-  "agent_messages",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    agent: text("agent").notNull(),
-    channel: text("channel").notNull(),
-    sender: text("sender"),
-    content: text("content").notNull(),
-    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [
-    index("idx_agent_messages_agent").on(table.agent),
-    index("idx_agent_messages_channel").on(table.agent, table.channel)
-  ]
-);
-var conversationParticipants = sqliteTable(
-  "conversation_participants",
-  {
-    conversation_id: text("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
-    user_id: integer("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    role: text("role").notNull().default("member"),
-    joined_at: text("joined_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [
-    uniqueIndex("idx_cp_unique").on(table.conversation_id, table.user_id),
-    index("idx_cp_user_id").on(table.user_id)
-  ]
-);
-var sessions = sqliteTable("sessions", {
-  id: text("id").primaryKey(),
-  userId: integer("user_id").references(() => users.id, { onDelete: "cascade" }).notNull(),
-  createdAt: integer("created_at").notNull()
-});
-var messages = sqliteTable(
-  "messages",
-  {
-    id: integer("id").primaryKey({ autoIncrement: true }),
-    conversation_id: text("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
-    role: text("role").notNull(),
-    sender_name: text("sender_name"),
-    content: text("content").notNull(),
-    created_at: text("created_at").notNull().default(sql`(datetime('now'))`)
-  },
-  (table) => [index("idx_messages_conversation_id").on(table.conversation_id)]
-);
-
-// src/lib/db.ts
-var __dirname = dirname(fileURLToPath(import.meta.url));
-var migrationsFolder = existsSync(resolve(__dirname, "../drizzle")) ? resolve(__dirname, "../drizzle") : resolve(__dirname, "../../drizzle");
-var db = null;
-async function getDb() {
-  if (db) return db;
-  const dbPath = process.env.VOLUTE_DB_PATH || resolve(voluteHome(), "volute.db");
-  db = drizzle({ connection: { url: `file:${dbPath}` }, schema: schema_exports });
-  await migrate(db, { migrationsFolder });
-  try {
-    chmodSync(dbPath, 384);
-  } catch (err) {
-    console.error(
-      `[volute] WARNING: Failed to restrict database file permissions on ${dbPath}:`,
-      err
-    );
-  }
-  return db;
-}
-
-// src/lib/auth.ts
-async function createUser(username, password) {
-  const db2 = await getDb();
-  const hash = hashSync(password, 10);
-  const [{ value }] = await db2.select({ value: count() }).from(users).where(eq(users.user_type, "human"));
-  const role = value === 0 ? "admin" : "pending";
-  const [result] = await db2.insert(users).values({ username, password_hash: hash, role }).returning({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  });
-  return result;
-}
-async function verifyUser(username, password) {
-  const db2 = await getDb();
-  const row = await db2.select().from(users).where(eq(users.username, username)).get();
-  if (!row) return null;
-  if (row.user_type === "agent") return null;
-  if (!compareSync(password, row.password_hash)) return null;
-  const { password_hash: _, ...user } = row;
-  return user;
-}
-async function getUser(id) {
-  const db2 = await getDb();
-  const row = await db2.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).where(eq(users.id, id)).get();
-  return row ?? null;
-}
-async function getUserByUsername(username) {
-  const db2 = await getDb();
-  const row = await db2.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).where(eq(users.username, username)).get();
-  return row ?? null;
-}
-async function listUsers() {
-  const db2 = await getDb();
-  return db2.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).orderBy(users.created_at).all();
-}
-async function listPendingUsers() {
-  const db2 = await getDb();
-  return db2.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).where(eq(users.role, "pending")).orderBy(users.created_at).all();
-}
-async function listUsersByType(userType) {
-  const db2 = await getDb();
-  return db2.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).where(eq(users.user_type, userType)).orderBy(users.created_at).all();
-}
-async function getOrCreateAgentUser(agentName) {
-  const db2 = await getDb();
-  const existing = await db2.select({
-    id: users.id,
-    username: users.username,
-    role: users.role,
-    user_type: users.user_type,
-    created_at: users.created_at
-  }).from(users).where(and(eq(users.username, agentName), eq(users.user_type, "agent"))).get();
-  if (existing) return existing;
-  try {
-    const [result] = await db2.insert(users).values({
-      username: agentName,
-      password_hash: "!agent",
-      role: "agent",
-      user_type: "agent"
-    }).returning({
-      id: users.id,
-      username: users.username,
-      role: users.role,
-      user_type: users.user_type,
-      created_at: users.created_at
-    });
-    return result;
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
-      const retried = await db2.select({
-        id: users.id,
-        username: users.username,
-        role: users.role,
-        user_type: users.user_type,
-        created_at: users.created_at
-      }).from(users).where(and(eq(users.username, agentName), eq(users.user_type, "agent"))).get();
-      if (retried) return retried;
-    }
-    throw err;
-  }
-}
-async function deleteAgentUser(agentName) {
-  const db2 = await getDb();
-  await db2.delete(users).where(and(eq(users.username, agentName), eq(users.user_type, "agent")));
-}
-async function approveUser(id) {
-  const db2 = await getDb();
-  await db2.update(users).set({ role: "user" }).where(and(eq(users.id, id), eq(users.role, "pending")));
-}
-
-export {
-  users,
-  conversations,
-  agentMessages,
-  conversationParticipants,
-  sessions,
-  messages,
-  getDb,
-  createUser,
-  verifyUser,
-  getUser,
-  getUserByUsername,
-  listUsers,
-  listPendingUsers,
-  listUsersByType,
-  getOrCreateAgentUser,
-  deleteAgentUser,
-  approveUser
-};

package/dist/chunk-NETNFBA5.js

@@ -1,28 +0,0 @@
-#!/usr/bin/env node
-
-// src/lib/volute-config.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname, resolve } from "path";
-function readJson(path) {
-  if (!existsSync(path)) return null;
-  try {
-    return JSON.parse(readFileSync(path, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function readVoluteConfig(agentDir) {
-  const path = resolve(agentDir, "home/.config/volute.json");
-  return readJson(path);
-}
-function writeVoluteConfig(agentDir, config) {
-  const path = resolve(agentDir, "home/.config/volute.json");
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(config, null, 2)}
-`);
-}
-
-export {
-  readVoluteConfig,
-  writeVoluteConfig
-};