writbase 0.1.0 → 0.1.2

package/dist/writbase.js

@@ -4,17 +4,18 @@
 import { Command } from "commander";
 
 // src/commands/init.ts
-import { webcrypto } from "crypto";
+import { webcrypto as webcrypto2 } from "crypto";
 import { execSync } from "child_process";
-import { existsSync } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
 import { confirm, input, select } from "@inquirer/prompts";
 import { createSpinner } from "nanospinner";
 
 // src/lib/config.ts
 import dotenv from "dotenv";
-import { writeFileSync, renameSync } from "fs";
+import { mkdirSync, writeFileSync, renameSync } from "fs";
 import { join } from "path";
+import { homedir } from "os";
 
 // src/lib/output.ts
 import pc from "picocolors";
@@ -44,8 +45,9 @@ function table(headers, rows) {
 }
 
 // src/lib/config.ts
+var WRITBASE_HOME = join(homedir(), ".writbase");
 function loadConfigPartial() {
-  dotenv.config();
+  dotenv.config({ path: join(WRITBASE_HOME, ".env") });
   return {
     supabaseUrl: process.env.SUPABASE_URL,
     supabaseServiceRoleKey: process.env.SUPABASE_SERVICE_ROLE_KEY,
@@ -68,8 +70,9 @@ function loadConfig() {
   return partial;
 }
 function writeEnv(vars) {
-  const envPath = join(process.cwd(), ".env");
-  const tmpPath = join(process.cwd(), ".env.tmp");
+  mkdirSync(WRITBASE_HOME, { recursive: true });
+  const envPath = join(WRITBASE_HOME, ".env");
+  const tmpPath = join(WRITBASE_HOME, ".env.tmp");
   const content = Object.entries(vars).map(([key2, value]) => `${key2}=${value}`).join("\n") + "\n";
   writeFileSync(tmpPath, content, { mode: 384 });
   renameSync(tmpPath, envPath);
@@ -86,15 +89,221 @@ function createAdminClient(url, key2) {
   });
 }
 
+// src/lib/agent-keys.ts
+import { webcrypto } from "crypto";
+
+// src/lib/event-log.ts
+async function logEvent(supabase, params) {
+  const { error: error2 } = await supabase.from("event_log").insert({
+    event_category: params.eventCategory,
+    target_type: params.targetType,
+    target_id: params.targetId,
+    event_type: params.eventType,
+    field_name: params.fieldName ?? null,
+    old_value: params.oldValue ?? null,
+    new_value: params.newValue ?? null,
+    actor_type: params.actorType,
+    actor_id: params.actorId,
+    actor_label: params.actorLabel,
+    source: params.source,
+    workspace_id: params.workspaceId
+  });
+  if (error2) {
+    console.error(
+      "Failed to log event:",
+      JSON.stringify({
+        event_type: params.eventType,
+        target_id: params.targetId,
+        error: error2.message
+      })
+    );
+  }
+}
+
+// src/lib/agent-keys.ts
+async function hashSecret(secret) {
+  const data = new TextEncoder().encode(secret);
+  const hashBuffer = await webcrypto.subtle.digest("SHA-256", data);
+  return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function generateKey(keyId) {
+  const randomBytes = new Uint8Array(32);
+  webcrypto.getRandomValues(randomBytes);
+  const secret = Array.from(randomBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const hash = await hashSecret(secret);
+  const prefix = secret.slice(0, 8);
+  const fullKey = `wb_${keyId}_${secret}`;
+  return { fullKey, prefix, hash };
+}
+var KEY_COLUMNS = "id, name, role, key_prefix, is_active, special_prompt, created_at, last_used_at, created_by, project_id, department_id";
+async function listAgentKeys(supabase, workspaceId) {
+  const { data, error: error2 } = await supabase.from("agent_keys").select(KEY_COLUMNS).eq("workspace_id", workspaceId).order("created_at", { ascending: false });
+  if (error2) throw error2;
+  return data;
+}
+async function createAgentKey(supabase, params) {
+  const keyId = webcrypto.randomUUID();
+  const { fullKey, prefix, hash } = await generateKey(keyId);
+  const { data, error: error2 } = await supabase.from("agent_keys").insert({
+    id: keyId,
+    name: params.name,
+    role: params.role ?? "worker",
+    key_hash: hash,
+    key_prefix: prefix,
+    special_prompt: null,
+    created_by: "writbase-cli",
+    workspace_id: params.workspaceId,
+    project_id: params.projectId ?? null,
+    department_id: params.departmentId ?? null
+  }).select(KEY_COLUMNS).single();
+  if (error2) throw error2;
+  await logEvent(supabase, {
+    eventCategory: "admin",
+    targetType: "agent_key",
+    targetId: data.id,
+    eventType: "agent_key.created",
+    actorType: "system",
+    actorId: "writbase-cli",
+    actorLabel: "writbase-cli",
+    source: "system",
+    workspaceId: params.workspaceId
+  });
+  return { key: data, fullKey };
+}
+async function rotateAgentKey(supabase, params) {
+  const { fullKey, prefix, hash } = await generateKey(params.id);
+  const { data, error: error2 } = await supabase.from("agent_keys").update({ key_hash: hash, key_prefix: prefix }).eq("id", params.id).eq("workspace_id", params.workspaceId).select(KEY_COLUMNS).single();
+  if (error2) throw error2;
+  await logEvent(supabase, {
+    eventCategory: "admin",
+    targetType: "agent_key",
+    targetId: params.id,
+    eventType: "agent_key.rotated",
+    actorType: "system",
+    actorId: "writbase-cli",
+    actorLabel: "writbase-cli",
+    source: "system",
+    workspaceId: params.workspaceId
+  });
+  return { key: data, fullKey };
+}
+async function deactivateAgentKey(supabase, params) {
+  const { data, error: error2 } = await supabase.from("agent_keys").update({ is_active: false }).eq("id", params.id).eq("workspace_id", params.workspaceId).select(KEY_COLUMNS).single();
+  if (error2) throw error2;
+  await logEvent(supabase, {
+    eventCategory: "admin",
+    targetType: "agent_key",
+    targetId: params.id,
+    eventType: "agent_key.deactivated",
+    actorType: "system",
+    actorId: "writbase-cli",
+    actorLabel: "writbase-cli",
+    source: "system",
+    workspaceId: params.workspaceId
+  });
+  return data;
+}
+
+// src/lib/claude-code.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { fileURLToPath } from "url";
+import { existsSync, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync, renameSync as renameSync2, cpSync } from "fs";
+function generatePluginJson() {
+  return JSON.stringify(
+    {
+      name: "writbase",
+      description: "WritBase \u2014 agent-first task management. Skills for MCP tool usage, permissions, and error handling.",
+      version: "0.1.2"
+    },
+    null,
+    2
+  );
+}
+function generateMcpJson(mcpUrl, agentKey) {
+  return JSON.stringify(
+    {
+      writbase: {
+        type: "http",
+        url: mcpUrl,
+        headers: {
+          Authorization: `Bearer ${agentKey}`
+        }
+      }
+    },
+    null,
+    2
+  );
+}
+function atomicWriteJson(filePath, content) {
+  const tmpPath = filePath + ".tmp";
+  writeFileSync2(tmpPath, content);
+  renameSync2(tmpPath, filePath);
+}
+function installPlugin(config) {
+  const claudeDir = join2(homedir2(), ".claude");
+  mkdirSync2(join2(WRITBASE_HOME, ".claude-plugin"), { recursive: true });
+  mkdirSync2(join2(WRITBASE_HOME, "skills"), { recursive: true });
+  const packageRoot = fileURLToPath(new URL("..", import.meta.url));
+  const skillsSource = join2(packageRoot, "skills");
+  cpSync(skillsSource, join2(WRITBASE_HOME, "skills"), { recursive: true });
+  writeFileSync2(join2(WRITBASE_HOME, ".claude-plugin", "plugin.json"), generatePluginJson());
+  const mcpContent = generateMcpJson(config.mcpUrl, config.agentKey);
+  const mcpPath = join2(WRITBASE_HOME, ".mcp.json");
+  const mcpTmpPath = join2(WRITBASE_HOME, ".mcp.json.tmp");
+  writeFileSync2(mcpTmpPath, mcpContent, { mode: 384 });
+  renameSync2(mcpTmpPath, mcpPath);
+  const pluginsDir = join2(claudeDir, "plugins");
+  mkdirSync2(pluginsDir, { recursive: true });
+  const marketplacesPath = join2(pluginsDir, "known_marketplaces.json");
+  const marketplaces = existsSync(marketplacesPath) ? JSON.parse(readFileSync(marketplacesPath, "utf-8")) : {};
+  marketplaces["writbase"] = {
+    source: { source: "directory", path: WRITBASE_HOME },
+    autoUpdate: false
+  };
+  atomicWriteJson(marketplacesPath, JSON.stringify(marketplaces, null, 2));
+  const settingsPath = join2(claudeDir, "settings.json");
+  const settings = existsSync(settingsPath) ? JSON.parse(readFileSync(settingsPath, "utf-8")) : {};
+  if (!settings.enabledPlugins) {
+    settings.enabledPlugins = {};
+  }
+  settings.enabledPlugins["writbase@writbase"] = true;
+  atomicWriteJson(settingsPath, JSON.stringify(settings, null, 2));
+}
+async function grantBasicPermissions(supabase, params) {
+  const perms = {
+    agent_key_id: params.keyId,
+    project_id: params.projectId,
+    workspace_id: params.workspaceId,
+    can_read: true,
+    can_create: true,
+    can_update: true,
+    can_assign: params.role === "manager"
+  };
+  const { error: error2 } = await supabase.from("agent_permissions").insert(perms);
+  if (error2) throw error2;
+  await logEvent(supabase, {
+    eventCategory: "admin",
+    targetType: "agent_key",
+    targetId: params.keyId,
+    eventType: "agent_permission.granted",
+    actorType: "system",
+    actorId: "writbase-cli",
+    actorLabel: "writbase-cli",
+    source: "system",
+    workspaceId: params.workspaceId
+  });
+}
+
 // src/commands/init.ts
 async function initCommand() {
   console.log();
   info("WritBase \u2014 Interactive Setup");
   console.log();
-  const envPath = join2(process.cwd(), ".env");
-  if (existsSync(envPath)) {
+  const envPath = join3(WRITBASE_HOME, ".env");
+  if (existsSync2(envPath)) {
     const overwrite = await confirm({
-      message: ".env file already exists. Reconfigure?",
+      message: `${WRITBASE_HOME} already configured. Reconfigure?`,
       default: false
     });
     if (!overwrite) return;
@@ -207,7 +416,7 @@ async function initCommand() {
       SUPABASE_SERVICE_ROLE_KEY: serviceRoleKey,
       DATABASE_URL: databaseUrl
     });
-    success(".env written (partial \u2014 no workspace yet)");
+    success(`Config written to ${WRITBASE_HOME} (partial \u2014 no workspace yet)`);
     console.log();
     info("Next steps:");
     console.log("  1. writbase migrate");
@@ -236,7 +445,7 @@ async function initCommand() {
     try {
       const { data: user, error: userError } = await supabase.auth.admin.createUser({
         email: "system@writbase.local",
-        password: webcrypto.randomUUID(),
+        password: webcrypto2.randomUUID(),
         email_confirm: true
       });
       let userId;
@@ -279,25 +488,94 @@ async function initCommand() {
     WRITBASE_WORKSPACE_ID: workspaceId
   });
   console.log();
-  success(".env written");
+  success(`Config written to ${WRITBASE_HOME}`);
+  console.log();
+  const setupClaude = await confirm({
+    message: "Set up Claude Code integration? (installs skills + MCP config globally)",
+    default: true
+  });
+  if (setupClaude) {
+    const keyName = await input({
+      message: "Agent key name:",
+      default: "claude-code"
+    });
+    const keyRole = await select({
+      message: "Agent role:",
+      choices: [
+        { name: "worker", value: "worker" },
+        { name: "manager", value: "manager" }
+      ],
+      default: "worker"
+    });
+    const { data: projects } = await supabase.from("projects").select("id, name, slug").eq("workspace_id", workspaceId).eq("is_archived", false).order("name");
+    let projectId = null;
+    if (projects && projects.length > 0) {
+      if (projects.length === 1) {
+        projectId = projects[0].id;
+        info(`Using project: ${projects[0].name} (${projects[0].slug})`);
+      } else {
+        projectId = await select({
+          message: "Grant permissions for project:",
+          choices: projects.map((p) => ({
+            name: `${p.name} (${p.slug})`,
+            value: p.id
+          }))
+        });
+      }
+    }
+    const mcpUrl = await input({
+      message: "MCP endpoint URL:",
+      default: `${supabaseUrl}/functions/v1/mcp-server`
+    });
+    const keySpinner = createSpinner("Creating agent key...").start();
+    try {
+      const { key: key2, fullKey } = await createAgentKey(supabase, {
+        name: keyName.trim() || "claude-code",
+        role: keyRole,
+        workspaceId,
+        projectId
+      });
+      keySpinner.success({ text: `Agent key created: ${key2.name} (${key2.role})` });
+      if (projectId) {
+        await grantBasicPermissions(supabase, {
+          keyId: key2.id,
+          projectId,
+          workspaceId,
+          role: keyRole
+        });
+        success("Permissions granted");
+      }
+      const pluginSpinner = createSpinner("Installing Claude Code plugin...").start();
+      installPlugin({ mcpUrl, agentKey: fullKey });
+      pluginSpinner.success({ text: "Claude Code plugin installed" });
+      console.log();
+      warn("Save this agent key \u2014 it cannot be retrieved later:");
+      console.log();
+      console.log(`  ${fullKey}`);
+      console.log();
+      success("Claude Code integration complete. Restart Claude Code to activate.");
+    } catch (err) {
+      keySpinner.error({ text: "Claude Code setup failed" });
+      error(err instanceof Error ? err.message : String(err));
+      console.log();
+      info("You can set up Claude Code later with `writbase key create`");
+    }
+  }
   console.log();
   info("Next steps:");
-  if (!schemaExists) {
-    console.log("  1. writbase migrate");
-    console.log("  2. writbase key create");
-  } else {
+  if (!setupClaude) {
     console.log("  1. writbase key create");
   }
-  console.log("  Then: writbase status");
+  console.log("  writbase status    (verify connection)");
   console.log();
 }
 
 // src/commands/migrate.ts
 import { execSync as execSync2 } from "child_process";
-import { mkdtempSync, mkdirSync, cpSync, writeFileSync as writeFileSync2, rmSync } from "fs";
-import { join as join3 } from "path";
+import { mkdtempSync, mkdirSync as mkdirSync3, cpSync as cpSync2, writeFileSync as writeFileSync3, rmSync } from "fs";
+import { join as join4 } from "path";
 import { tmpdir } from "os";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { createSpinner as createSpinner2 } from "nanospinner";
 var CONFIG_TOML = `project_id = "writbase"
 
@@ -319,15 +597,15 @@ async function migrateCommand(opts) {
     error("Supabase CLI not found. Install it: https://supabase.com/docs/guides/cli");
     process.exit(1);
   }
-  const packageRoot = fileURLToPath(new URL("..", import.meta.url));
-  const migrationsSource = join3(packageRoot, "migrations");
+  const packageRoot = fileURLToPath2(new URL("..", import.meta.url));
+  const migrationsSource = join4(packageRoot, "migrations");
   const spinner = createSpinner2("Running migrations...").start();
-  const tmpDir = mkdtempSync(join3(tmpdir(), "writbase-migrate-"));
+  const tmpDir = mkdtempSync(join4(tmpdir(), "writbase-migrate-"));
   try {
-    const supabaseDir = join3(tmpDir, "supabase");
-    mkdirSync(supabaseDir);
-    writeFileSync2(join3(supabaseDir, "config.toml"), CONFIG_TOML);
-    cpSync(migrationsSource, join3(supabaseDir, "migrations"), { recursive: true });
+    const supabaseDir = join4(tmpDir, "supabase");
+    mkdirSync3(supabaseDir);
+    writeFileSync3(join4(supabaseDir, "config.toml"), CONFIG_TOML);
+    cpSync2(migrationsSource, join4(supabaseDir, "migrations"), { recursive: true });
     const args = [`--db-url "${config.databaseUrl}"`, `--workdir ${tmpDir}`];
     if (opts.dryRun) args.push("--dry-run");
     const cmd = `supabase migration up ${args.join(" ")}`;
@@ -360,123 +638,6 @@ async function migrateCommand(opts) {
 // src/commands/key.ts
 import { confirm as confirm2, input as input2, select as select2 } from "@inquirer/prompts";
 import { createSpinner as createSpinner3 } from "nanospinner";
-
-// src/lib/agent-keys.ts
-import { webcrypto as webcrypto2 } from "crypto";
-
-// src/lib/event-log.ts
-async function logEvent(supabase, params) {
-  const { error: error2 } = await supabase.from("event_log").insert({
-    event_category: params.eventCategory,
-    target_type: params.targetType,
-    target_id: params.targetId,
-    event_type: params.eventType,
-    field_name: params.fieldName ?? null,
-    old_value: params.oldValue ?? null,
-    new_value: params.newValue ?? null,
-    actor_type: params.actorType,
-    actor_id: params.actorId,
-    actor_label: params.actorLabel,
-    source: params.source,
-    workspace_id: params.workspaceId
-  });
-  if (error2) {
-    console.error(
-      "Failed to log event:",
-      JSON.stringify({
-        event_type: params.eventType,
-        target_id: params.targetId,
-        error: error2.message
-      })
-    );
-  }
-}
-
-// src/lib/agent-keys.ts
-async function hashSecret(secret) {
-  const data = new TextEncoder().encode(secret);
-  const hashBuffer = await webcrypto2.subtle.digest("SHA-256", data);
-  return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-async function generateKey(keyId) {
-  const randomBytes = new Uint8Array(32);
-  webcrypto2.getRandomValues(randomBytes);
-  const secret = Array.from(randomBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-  const hash = await hashSecret(secret);
-  const prefix = secret.slice(0, 8);
-  const fullKey = `wb_${keyId}_${secret}`;
-  return { fullKey, prefix, hash };
-}
-var KEY_COLUMNS = "id, name, role, key_prefix, is_active, special_prompt, created_at, last_used_at, created_by, project_id, department_id";
-async function listAgentKeys(supabase, workspaceId) {
-  const { data, error: error2 } = await supabase.from("agent_keys").select(KEY_COLUMNS).eq("workspace_id", workspaceId).order("created_at", { ascending: false });
-  if (error2) throw error2;
-  return data;
-}
-async function createAgentKey(supabase, params) {
-  const keyId = webcrypto2.randomUUID();
-  const { fullKey, prefix, hash } = await generateKey(keyId);
-  const { data, error: error2 } = await supabase.from("agent_keys").insert({
-    id: keyId,
-    name: params.name,
-    role: params.role ?? "worker",
-    key_hash: hash,
-    key_prefix: prefix,
-    special_prompt: null,
-    created_by: "writbase-cli",
-    workspace_id: params.workspaceId,
-    project_id: params.projectId ?? null,
-    department_id: params.departmentId ?? null
-  }).select(KEY_COLUMNS).single();
-  if (error2) throw error2;
-  await logEvent(supabase, {
-    eventCategory: "admin",
-    targetType: "agent_key",
-    targetId: data.id,
-    eventType: "agent_key.created",
-    actorType: "system",
-    actorId: "writbase-cli",
-    actorLabel: "writbase-cli",
-    source: "system",
-    workspaceId: params.workspaceId
-  });
-  return { key: data, fullKey };
-}
-async function rotateAgentKey(supabase, params) {
-  const { fullKey, prefix, hash } = await generateKey(params.id);
-  const { data, error: error2 } = await supabase.from("agent_keys").update({ key_hash: hash, key_prefix: prefix }).eq("id", params.id).eq("workspace_id", params.workspaceId).select(KEY_COLUMNS).single();
-  if (error2) throw error2;
-  await logEvent(supabase, {
-    eventCategory: "admin",
-    targetType: "agent_key",
-    targetId: params.id,
-    eventType: "agent_key.rotated",
-    actorType: "system",
-    actorId: "writbase-cli",
-    actorLabel: "writbase-cli",
-    source: "system",
-    workspaceId: params.workspaceId
-  });
-  return { key: data, fullKey };
-}
-async function deactivateAgentKey(supabase, params) {
-  const { data, error: error2 } = await supabase.from("agent_keys").update({ is_active: false }).eq("id", params.id).eq("workspace_id", params.workspaceId).select(KEY_COLUMNS).single();
-  if (error2) throw error2;
-  await logEvent(supabase, {
-    eventCategory: "admin",
-    targetType: "agent_key",
-    targetId: params.id,
-    eventType: "agent_key.deactivated",
-    actorType: "system",
-    actorId: "writbase-cli",
-    actorLabel: "writbase-cli",
-    source: "system",
-    workspaceId: params.workspaceId
-  });
-  return data;
-}
-
-// src/commands/key.ts
 async function resolveKeyByNameOrId(supabase, workspaceId, nameOrId) {
   const keys = await listAgentKeys(supabase, workspaceId);
   const byName = keys.find(
@@ -695,7 +856,7 @@ async function statusCommand() {
 
 // src/bin/writbase.ts
 var program = new Command();
-program.name("writbase").description("WritBase CLI \u2014 agent-first task management").version("0.1.0");
+program.name("writbase").description("WritBase CLI \u2014 agent-first task management").version("0.1.2");
 program.command("init").description("Interactive setup \u2014 configure credentials and workspace").action(initCommand);
 program.command("migrate").description("Apply database migrations via supabase migration up").option("--dry-run", "Show what would be applied without making changes").action(migrateCommand);
 var key = program.command("key").description("Manage agent keys");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "writbase",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "description": "WritBase CLI — self-hosted operator toolkit for agent-first task management",
   "bin": {
@@ -8,7 +8,8 @@
   },
   "files": [
     "dist/",
-    "migrations/"
+    "migrations/",
+    "skills/"
   ],
   "scripts": {
     "build": "tsup src/bin/writbase.ts --format esm --target node18",