@rendotdev/rig 0.0.17 → 0.0.19

package/README.md

@@ -68,11 +68,15 @@ The `rig` CLI is installed on this machine. It allows you to write, run and own
 - To discover available tools, run `rig list`.
 - To learn about a tool's usage, run `rig help <tool>`.
 - To run a tool, use `rig run <tool>.<command> [args]`.
+- Tools run under Bun with fallback auto-install enabled, so tool files can import npm packages; add explicit package versions when reproducibility matters.
+- To schedule a tool command, use `rig cron add <name> <tool>.<command> <schedule> --input '<json>'`; use `rig cron list`, `rig cron run <name>`, and `rig cron remove <name>` to manage scheduled runs.
+- If a tool needs local secrets or settings, put them in the tool folder's `.env`, add an `env` Zod schema to the tool definition, and read validated values from `context.env`.
 - To create a new tool, run `rig create <tool>`.
 - To edit an existing tool, run `rig edit <tool>` and open the printed file path.
 - To remove an existing tool, run `rig remove <tool>`.
 - To list tool registries, run `rig registry list`.
 - To add a registry, run `rig registry create [path]` (defaults to current directory).
+- If a tool needs persistent state, define `setupDb` and use `context.db`; Rig stores that SQLite database beside the tool entry file as `index.sqlite`.
 
 When rig runs, it keeps detected `AGENTS.md` and `CLAUDE.md` files updated with these instructions and the current `rig list` output.
 

package/dist/{run-y66hvyxg.js → cli-113n7c3t.js}

@@ -1,20 +1,15 @@
 import {
   SchemaRenderer
-} from "./cli-dshh1cp9.js";
+} from "./cli-884hpkjc.js";
 import {
   CommandIds,
   ToolLoader,
   createRigToolKit
-} from "./cli-7zqnqrah.js";
-import"./cli-vx11bmzr.js";
-import"./cli-xv4m20sx.js";
-import"./cli-aj56a1ja.js";
+} from "./cli-f7p31fzm.js";
 import {
   RigError,
   RigErrors
 } from "./cli-1c7te5cg.js";
-import"./cli-ne7ed594.js";
-import"./cli-b7jgjgy7.js";
 
 // src/tools/run.ts
 import { readFile } from "node:fs/promises";
@@ -94,7 +89,11 @@ class OutputTempFileStore {
   async writeJson(content) {
     const dir = await mkdtemp(join(tmpdir(), "rig-output-"));
     const path = join(dir, "data.json");
-    await writeFile(path, `${content}
+    if (typeof Bun !== "undefined")
+      await Bun.write(path, `${content}
+`);
+    else
+      await writeFile(path, `${content}
 `, "utf8");
     return path;
   }
@@ -156,6 +155,138 @@ class RigOutputTruncator {
   }
 }
 
+// src/tools/db.ts
+import { createHash } from "node:crypto";
+import { mkdir } from "node:fs/promises";
+import { dirname, join as join2 } from "node:path";
+class MigrationChecksum {
+  digest(version, name, sql) {
+    return createHash("sha256").update(`${version}\x00${name}\x00${sql}`).digest("hex");
+  }
+}
+
+class RigDatabaseMigrator {
+  db;
+  lastVersion = 0;
+  checksums = new MigrationChecksum;
+  constructor(db) {
+    this.db = db;
+  }
+  ensureMetadata() {
+    this.db.run(`
+      create table if not exists _rig_migrations (
+        version integer primary key,
+        name text not null,
+        checksum text not null,
+        applied_at text not null
+      );
+    `);
+  }
+  migrate(version, name, sql) {
+    this.validate(version, name, sql);
+    const checksum = this.checksums.digest(version, name, sql);
+    const existing = this.existingMigration(version);
+    if (existing) {
+      this.assertExistingMigrationMatches(version, name, checksum, existing);
+      return;
+    }
+    const apply = this.db.transaction(() => {
+      this.db.run(sql);
+      this.db.query(`insert into _rig_migrations (version, name, checksum, applied_at)
+           values ($version, $name, $checksum, $appliedAt)`).run({ version, name, checksum, appliedAt: new Date().toISOString() });
+    });
+    apply();
+  }
+  validate(version, name, sql) {
+    if (!Number.isInteger(version) || version <= 0) {
+      throw new RigError("TOOL_INVALID", `Migration version must be a positive integer: ${version}`);
+    }
+    if (version <= this.lastVersion) {
+      throw new RigError("TOOL_INVALID", `Migration versions must be declared in ascending order: ${version} after ${this.lastVersion}`);
+    }
+    if (!name.trim())
+      throw new RigError("TOOL_INVALID", "Migration name must not be empty.");
+    if (!sql.trim())
+      throw new RigError("TOOL_INVALID", `Migration ${version} SQL must not be empty.`);
+    this.lastVersion = version;
+  }
+  existingMigration(version) {
+    const row = this.db.query("select name, checksum from _rig_migrations where version = ?").get(version);
+    return row ?? undefined;
+  }
+  assertExistingMigrationMatches(version, name, checksum, existing) {
+    if (existing.name === name && existing.checksum === checksum)
+      return;
+    throw new RigError("TOOL_INVALID", `Migration ${version} has changed since it was applied.`, {
+      version,
+      expected: existing,
+      actual: { name, checksum }
+    });
+  }
+}
+
+class BunSqliteModuleLoader {
+  async database() {
+    const database = globalThis.rigSqliteDatabaseForTests;
+    if (!database)
+      return this.nativeDatabase();
+    return database;
+  }
+  async nativeDatabase() {
+    const specifier = "bun:sqlite";
+    const moduleValue = await import(specifier);
+    return moduleValue.Database;
+  }
+}
+
+class RigToolDatabaseFactory {
+  sqlite = new BunSqliteModuleLoader;
+  async create(toolPath) {
+    const dbPath = this.dbPathForToolPath(toolPath);
+    await mkdir(dirname(dbPath), { recursive: true });
+    const Database = await this.sqlite.database();
+    const db = new Database(dbPath, { create: true, strict: true });
+    const migrator = new RigDatabaseMigrator(db);
+    Object.defineProperty(db, "path", { value: dbPath, enumerable: true });
+    Object.defineProperty(db, "migrate", {
+      value: (version, name, sql) => migrator.migrate(version, name, sql),
+      enumerable: true
+    });
+    db.run("PRAGMA journal_mode = WAL;");
+    migrator.ensureMetadata();
+    return db;
+  }
+  dbPathForToolPath(toolPath) {
+    return join2(dirname(toolPath), "index.sqlite");
+  }
+}
+
+class UnavailableToolDatabaseFactory {
+  create(toolName) {
+    return new Proxy({}, {
+      get() {
+        throw new RigError("TOOL_INVALID", `Tool ${toolName} must define setupDb before using context.db.`, {
+          tool: toolName
+        });
+      }
+    });
+  }
+}
+
+class ToolDatabaseService {
+  factory = new RigToolDatabaseFactory;
+  async setup(tool) {
+    if (!tool.definition.setupDb)
+      return;
+    const db = await this.factory.create(tool.path);
+    await tool.definition.setupDb(db);
+    return db;
+  }
+  dbPathForToolPath(toolPath) {
+    return this.factory.dbPathForToolPath(toolPath);
+  }
+}
+
 // src/tools/run.ts
 class RunInputReader {
   async read(command, options) {
@@ -169,8 +300,8 @@ class RunInputReader {
       throw new RigError("INPUT_ERROR", "Use args, --input, or --input-file, not more than one.");
     }
     if (options.inputFile) {
-      const raw = await readFile(options.inputFile, "utf8");
-      return { value: JSON.parse(raw), source: `--input-file ${options.inputFile}` };
+      const value = typeof Bun !== "undefined" ? await Bun.file(options.inputFile).json() : JSON.parse(await readFile(options.inputFile, "utf8"));
+      return { value, source: `--input-file ${options.inputFile}` };
     }
     if (options.input) {
       return { value: JSON.parse(options.input), source: `--input '${options.input}'` };
@@ -300,16 +431,19 @@ class DryRunPresenter {
 
 class ToolRunner {
   options;
+  databases = new ToolDatabaseService;
   loader;
   inputReader = new RunInputReader;
   outputTruncator = new RigOutputTruncator;
+  unavailableDatabases = new UnavailableToolDatabaseFactory;
   constructor(options = {}) {
     this.options = options;
     this.loader = new ToolLoader(options);
   }
   async run(toolName, commandName, options = {}) {
+    let db;
     try {
-      const { command } = await this.loader.loadCommand(toolName, commandName);
+      const { tool, command } = await this.loader.loadCommand(toolName, commandName);
       const input = await this.inputReader.read(command, options);
       const inputResult = command.input.safeParse(input.value);
       if (!inputResult.success) {
@@ -330,11 +464,13 @@ class ToolRunner {
         };
       }
       const rig = createRigToolKit(this.options);
+      db = await this.databases.setup(tool);
       const data = await command.run({
         input: inputResult.data,
-        env: process.env,
+        env: tool.env,
+        processEnv: process.env,
         cwd: process.cwd(),
-        shell: rig.shell,
+        db: db ?? this.unavailableDatabases.create(toolName),
         rig
       });
       const outputResult = command.output.safeParse(data);
@@ -357,8 +493,15 @@ class ToolRunner {
         }),
         exitCode: 1
       };
+    } finally {
+      this.closeDatabase(db);
     }
   }
+  closeDatabase(db) {
+    try {
+      db?.close(false);
+    } catch {}
+  }
   asInputAwareRigError(error) {
     if (error instanceof SyntaxError) {
       return new RigError("INPUT_ERROR", "Input JSON is invalid.", { message: error.message });
@@ -366,6 +509,5 @@ class ToolRunner {
     return RigErrors.from(error);
   }
 }
-export {
-  ToolRunner
-};
+
+export { ToolRunner };

package/dist/{cli-ne7ed594.js → cli-13q90bjr.js}

@@ -22,6 +22,9 @@ class RigPaths {
     return isAbsolute(expanded) ? resolve(expanded) : resolve(process.cwd(), expanded);
   }
   get rigDir() {
+    return join(this.homeDir, "rig");
+  }
+  get legacyRigDir() {
     return join(this.homeDir, ".rig");
   }
   get configPath() {
@@ -42,10 +45,19 @@ class RigPaths {
   get runtimeToolTsconfigPath() {
     return join(this.runtimeDir, "tsconfig.tools.json");
   }
+  get cronDir() {
+    return join(this.rigDir, "cron");
+  }
+  cronWorkerPath(name) {
+    return join(this.cronDir, `${name}.ts`);
+  }
   get updateCheckCachePath() {
     return join(this.rigDir, "update-check.json");
   }
   get defaultBaseRegistryDir() {
+    return "~/rig/tools";
+  }
+  get legacyDefaultBaseRegistryDir() {
     return "~/.rig/tools";
   }
   parentDir(pathValue) {

package/dist/{cli-vx11bmzr.js → cli-1hm5dxfw.js}

@@ -1,12 +1,12 @@
 import {
   RigConfigStore
-} from "./cli-xv4m20sx.js";
+} from "./cli-nk194xv0.js";
 import {
   RigError
 } from "./cli-1c7te5cg.js";
 import {
   RigPaths
-} from "./cli-ne7ed594.js";
+} from "./cli-13q90bjr.js";
 
 // src/registry/discover.ts
 import { existsSync, statSync } from "node:fs";

package/dist/{cli-dshh1cp9.js → cli-884hpkjc.js}

@@ -1,6 +1,6 @@
 import {
   exports_external
-} from "./cli-xv4m20sx.js";
+} from "./cli-nk194xv0.js";
 
 // src/tools/schema.ts
 class SchemaRenderer {

package/dist/cli-es8j6mma.js

@@ -0,0 +1,226 @@
+import {
+  ToolRunner
+} from "./cli-113n7c3t.js";
+import {
+  RigConfigStore
+} from "./cli-nk194xv0.js";
+import {
+  RigError
+} from "./cli-1c7te5cg.js";
+import {
+  RigPaths
+} from "./cli-13q90bjr.js";
+
+// src/tools/cron.ts
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+class BunCronRegistrar {
+  register(path, schedule, title) {
+    return this.cron()(path, schedule, title);
+  }
+  remove(title) {
+    return this.cron().remove(title);
+  }
+  validate(schedule) {
+    const next = this.cron().parse(schedule);
+    if (!next)
+      throw new RigError("CRON_ERROR", `Cron schedule has no future runs: ${schedule}`);
+  }
+  cron() {
+    const cron = globalThis.Bun?.cron;
+    if (typeof cron !== "function") {
+      throw new RigError("CRON_ERROR", "Bun cron is unavailable. Run rig with Bun.");
+    }
+    return cron;
+  }
+}
+
+class CronJobName {
+  value;
+  constructor(value) {
+    this.value = value;
+    if (!/^[A-Za-z0-9_-]+$/.test(value)) {
+      throw new RigError("INPUT_ERROR", "Cron job names may only contain letters, numbers, hyphens, and underscores.", { name: value });
+    }
+  }
+}
+
+class CronInputReader {
+  async read(options) {
+    if (options.input && options.inputFile) {
+      throw new RigError("INPUT_ERROR", "Use --input or --input-file, not both.");
+    }
+    if (options.inputFile) {
+      return typeof Bun !== "undefined" ? Bun.file(options.inputFile).json() : JSON.parse(await readFile(options.inputFile, "utf8"));
+    }
+    return options.input === undefined ? undefined : JSON.parse(options.input);
+  }
+}
+
+class CronCommandTarget {
+  id;
+  tool;
+  command;
+  constructor(id) {
+    this.id = id;
+    const parts = id.split(".");
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+      throw new RigError("INPUT_ERROR", `Command id must use <tool>.<command>: ${id}`);
+    }
+    this.tool = parts[0];
+    this.command = parts[1];
+  }
+}
+
+class CronWorkerScript {
+  render(params) {
+    const entrypoint = fileURLToPath(params.moduleUrl);
+    const env = params.homeDir ? { RIG_HOME: params.homeDir } : {};
+    return `export default {
+  async scheduled() {
+    const proc = Bun.spawn([
+      process.execPath,
+      "--install=fallback",
+      ${JSON.stringify(entrypoint)},
+      "cron",
+      "run",
+      ${JSON.stringify(params.name)},
+    ], {
+      stdout: "pipe",
+      stderr: "pipe",
+      env: { ...process.env, ...${JSON.stringify(env)} },
+    });
+
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ]);
+    if (stdout) console.log(stdout.trimEnd());
+    if (stderr) console.error(stderr.trimEnd());
+    if (exitCode !== 0) throw new Error("Rig cron job failed: " + ${JSON.stringify(params.name)});
+  },
+};
+`;
+  }
+}
+
+class RigCronService {
+  options;
+  registrar;
+  paths;
+  configStore;
+  inputReader = new CronInputReader;
+  workerScript = new CronWorkerScript;
+  constructor(options = {}, registrar = new BunCronRegistrar) {
+    this.options = options;
+    this.registrar = registrar;
+    this.paths = new RigPaths(options);
+    this.configStore = new RigConfigStore(options);
+  }
+  async list() {
+    const config = await this.configStore.ensure();
+    return {
+      cronJobs: [...config.cronJobs].toSorted((left, right) => left.name.localeCompare(right.name))
+    };
+  }
+  async add(options) {
+    const name = new CronJobName(options.name);
+    const target = new CronCommandTarget(options.command);
+    const input = await this.inputReader.read(options);
+    this.registrar.validate(options.schedule);
+    await this.validateCommand(target, input);
+    const config = await this.configStore.ensure();
+    const job = {
+      name: name.value,
+      command: target.id,
+      schedule: options.schedule,
+      ...input === undefined ? {} : { input }
+    };
+    const workerPath = this.paths.cronWorkerPath(name.value);
+    await this.writeWorker(workerPath, {
+      name: name.value,
+      homeDir: this.options.homeDir,
+      moduleUrl: options.moduleUrl
+    });
+    await this.configStore.write({
+      ...config,
+      cronJobs: [...config.cronJobs.filter((existing) => existing.name !== name.value), job]
+    });
+    try {
+      await this.registrar.register(workerPath, options.schedule, name.value);
+    } catch (error) {
+      await this.configStore.write(config);
+      await rm(workerPath, { force: true });
+      throw error;
+    }
+    return { job, workerPath };
+  }
+  async remove(nameValue) {
+    const name = new CronJobName(nameValue);
+    const config = await this.configStore.ensure();
+    const workerPath = this.paths.cronWorkerPath(name.value);
+    const nextJobs = config.cronJobs.filter((job) => job.name !== name.value);
+    await this.configStore.write({ ...config, cronJobs: nextJobs });
+    await this.registrar.remove(name.value);
+    await rm(workerPath, { force: true });
+    return { name: name.value, removed: nextJobs.length !== config.cronJobs.length, workerPath };
+  }
+  async run(nameValue) {
+    const name = new CronJobName(nameValue);
+    const config = await this.configStore.ensure();
+    const job = config.cronJobs.find((candidate) => candidate.name === name.value);
+    if (!job)
+      throw new RigError("CRON_ERROR", `Cron job not found: ${name.value}`, { name });
+    const target = new CronCommandTarget(job.command);
+    const result = await new ToolRunner(this.options).run(target.tool, target.command, {
+      ...this.options,
+      input: job.input === undefined ? undefined : JSON.stringify(job.input)
+    });
+    return { job, envelope: result.envelope, exitCode: result.exitCode };
+  }
+  async validateCommand(target, input) {
+    const result = await new ToolRunner(this.options).run(target.tool, target.command, {
+      ...this.options,
+      input: input === undefined ? undefined : JSON.stringify(input),
+      dryRun: true
+    });
+    if (result.exitCode !== 0) {
+      throw new RigError("CRON_ERROR", `Cron command validation failed: ${target.id}`, {
+        envelope: result.envelope
+      });
+    }
+  }
+  async writeWorker(workerPath, params) {
+    await mkdir(dirname(workerPath), { recursive: true });
+    await writeFile(workerPath, this.workerScript.render(params), "utf8");
+  }
+}
+
+class RigCronWorker {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async scheduled(name, controller) {
+    const result = await new RigCronService(this.options).run(name);
+    const envelope = result.envelope;
+    console.log(JSON.stringify({
+      cron: {
+        name: result.job.name,
+        command: result.job.command,
+        schedule: controller?.cron ?? result.job.schedule,
+        scheduledTime: controller?.scheduledTime,
+        type: controller?.type
+      },
+      result: envelope
+    }, null, 2));
+    process.exitCode = result.exitCode;
+  }
+}
+function cronModuleUrl(metaUrl) {
+  return pathToFileURL(fileURLToPath(metaUrl)).href;
+}
+
+export { RigCronService, RigCronWorker, cronModuleUrl };