@rendotdev/rig 0.0.17 → 0.0.18

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/cli-0p4wnh3p.js

@@ -0,0 +1,226 @@
+import {
+  ToolRunner
+} from "./cli-yahk2r84.js";
+import {
+  RigConfigStore
+} from "./cli-jbscjyqq.js";
+import {
+  RigError
+} from "./cli-1c7te5cg.js";
+import {
+  RigPaths
+} from "./cli-vkw9rcke.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 };

package/dist/{cli-mswdavqx.js → cli-96n231pn.js}

@@ -1,13 +1,13 @@
 import {
   SchemaRenderer
-} from "./cli-dshh1cp9.js";
+} from "./cli-f4k31gtc.js";
 import {
   CommandIds,
   ToolLoader
-} from "./cli-7zqnqrah.js";
+} from "./cli-c6y9p8v9.js";
 import {
   ToolDiscoveryService
-} from "./cli-vx11bmzr.js";
+} from "./cli-ggk7t6dg.js";
 
 // src/tools/list.ts
 class CommandRunExampleRenderer {

package/dist/{cli-7zqnqrah.js → cli-c6y9p8v9.js}

@@ -1,9 +1,9 @@
 import {
   ToolDiscoveryService
-} from "./cli-vx11bmzr.js";
+} from "./cli-ggk7t6dg.js";
 import {
   exports_external
-} from "./cli-xv4m20sx.js";
+} from "./cli-jbscjyqq.js";
 import {
   RigError
 } from "./cli-1c7te5cg.js";
@@ -12,8 +12,6 @@ import {
 } from "./cli-b7jgjgy7.js";
 
 // src/tools/types.ts
-var RigSchemaRoleSymbol = Symbol.for("rig.schemaRole");
-
 class CommandIds {
   static from(tool, command) {
     return `${tool}.${command}`;
@@ -238,7 +236,7 @@ class RigCommandRunnerRuntime {
   }
   async run(options) {
     const target = this.commandTarget(options);
-    const { ToolRunner } = await import("./run-y66hvyxg.js");
+    const { ToolRunner } = await import("./run-apb4mx5d.js");
     const result = await new ToolRunner(this.options).run(target.tool, target.command, {
       ...this.options,
       args: options.args,
@@ -272,9 +270,7 @@ class RigToolKitFactory {
     return {
       z: exports_external,
       defineTool: (definition) => definition,
-      command: (definition) => definition,
-      input: (value) => this.schema(value, "input"),
-      output: (value) => this.schema(value, "output"),
+      defineCommand: (definition) => definition,
       run: (options) => new RigCommandRunnerRuntime(this.options).run(options),
       $: (strings, ...values) => shell.$(strings, ...values),
       args: () => new RigArgsRuntime,
@@ -282,27 +278,9 @@ class RigToolKitFactory {
       shell
     };
   }
-  schema(value, role) {
-    const schema = this.isZodSchema(value) ? value : exports_external.object(value);
-    const existingRole = schema[RigSchemaRoleSymbol];
-    if (existingRole === role)
-      return schema;
-    Object.defineProperty(schema, RigSchemaRoleSymbol, {
-      value: role,
-      configurable: false,
-      enumerable: false,
-      writable: false
-    });
-    return schema;
-  }
-  isZodSchema(value) {
-    return typeof value === "object" && value !== null && typeof value.safeParse === "function";
-  }
 }
 var rig = new RigToolKitFactory().create();
-var command = rig.command;
-var input = rig.input;
-var output = rig.output;
+var defineCommand = rig.defineCommand;
 var run = rig.run;
 var args = rig.args;
 var paths = rig.paths;
@@ -311,6 +289,9 @@ function createRigToolKit(options = {}) {
 }
 
 // src/tools/loader.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname as dirname2, join as join2 } from "node:path";
 import { pathToFileURL } from "node:url";
 class ToolDefinitionValidator {
   validateToolName(name) {
@@ -346,6 +327,14 @@ class ToolDefinitionValidator {
         expected: "non-empty string"
       });
     }
+    if (value.setupDb !== undefined && typeof value.setupDb !== "function") {
+      throw new RigError("TOOL_INVALID", `Tool ${value.name} setupDb must be a function.`, {
+        expected: "function"
+      });
+    }
+    if (value.env !== undefined) {
+      this.validateSchema(value.env, "env", value.name);
+    }
     if (!this.isRecord(value.commands)) {
       throw new RigError("TOOL_INVALID", `Tool ${value.name} needs a commands object.`, {
         expected: "object"
@@ -355,8 +344,8 @@ class ToolDefinitionValidator {
     if (entries.length === 0) {
       throw new RigError("TOOL_INVALID", `Tool ${value.name} must define at least one command.`);
     }
-    for (const [commandName, command2] of entries) {
-      this.validateCommand(commandName, command2, value.name);
+    for (const [commandName, command] of entries) {
+      this.validateCommand(commandName, command, value.name);
     }
     return value;
   }
@@ -406,15 +395,8 @@ class ToolDefinitionValidator {
   }
   validateSchema(value, role, id) {
     if (!this.hasSafeParse(value)) {
-      throw new RigError("TOOL_INVALID", `Command ${id} needs a Rig ${role} schema.`, {
-        expected: `schema created with rig.${role}(...)`
-      });
-    }
-    const actualRole = value[RigSchemaRoleSymbol];
-    if (actualRole !== role) {
-      throw new RigError("TOOL_INVALID", `Command ${id} needs a Rig ${role} schema.`, {
-        expected: `rig.${role}(...)`,
-        actual: actualRole ?? "unbranded Zod schema"
+      throw new RigError("TOOL_INVALID", `Command ${id} needs a Zod schema for ${role}.`, {
+        expected: `rig.z.object({ ... })`
       });
     }
   }
@@ -426,9 +408,90 @@ class ToolDefinitionValidator {
   }
 }
 
+class ToolEnvFileParser {
+  parse(source, path) {
+    const env = {};
+    for (const [index, line] of source.split(/\r?\n/).entries()) {
+      const parsed = this.parseLine(line, path, index + 1);
+      if (parsed)
+        env[parsed.key] = parsed.value;
+    }
+    return env;
+  }
+  parseLine(line, path, lineNumber) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      return;
+    const match = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(trimmed);
+    if (!match) {
+      throw new RigError("TOOL_INVALID", "Invalid .env line.", {
+        path,
+        line: lineNumber
+      });
+    }
+    return { key: match[1], value: this.parseValue(match[2]) };
+  }
+  parseValue(value) {
+    const trimmed = value.trim();
+    if (trimmed.length < 2)
+      return trimmed;
+    const quote = trimmed[0];
+    if (quote !== '"' && quote !== "'" || trimmed.at(-1) !== quote)
+      return trimmed;
+    const inner = trimmed.slice(1, -1);
+    if (quote === "'")
+      return inner;
+    return inner.replaceAll("\\n", `
+`).replaceAll("\\r", "\r").replaceAll("\\t", "\t").replaceAll("\\\"", '"').replaceAll("\\\\", "\\");
+  }
+}
+
+class ToolEnvLoader {
+  parser = new ToolEnvFileParser;
+  async load(tool, definition) {
+    const envPath = join2(dirname2(tool.toolPath), ".env");
+    const fileExists = await this.exists(envPath);
+    if (!definition.env) {
+      if (fileExists) {
+        throw new RigError("TOOL_INVALID", `Tool ${definition.name} has .env but no env schema.`, {
+          path: envPath
+        });
+      }
+      return {};
+    }
+    const rawEnv = fileExists ? this.parser.parse(await this.readText(envPath), envPath) : {};
+    const result = definition.env.safeParse(rawEnv);
+    if (!result.success) {
+      throw new RigError("TOOL_INVALID", `Tool ${definition.name} env is invalid.`, {
+        path: envPath,
+        errors: result.error.flatten()
+      });
+    }
+    return result.data;
+  }
+  async exists(path) {
+    const bunFile = this.bunFile();
+    if (bunFile) {
+      return bunFile(path).exists();
+    }
+    return existsSync2(path);
+  }
+  async readText(path) {
+    const bunFile = this.bunFile();
+    if (bunFile)
+      return bunFile(path).text();
+    return readFile(path, "utf8");
+  }
+  bunFile() {
+    const candidate = globalThis.Bun?.file;
+    return typeof candidate === "function" ? candidate : undefined;
+  }
+}
+
 class ToolLoader {
   discovery;
   validator;
+  envLoader = new ToolEnvLoader;
   constructor(options = {}) {
     this.discovery = new ToolDiscoveryService(options);
     this.validator = new ToolDefinitionValidator;
@@ -453,7 +516,8 @@ class ToolLoader {
     const moduleRecord = moduleValue;
     const definitionValue = await this.evaluateModuleDefault(moduleRecord.default, tool.name);
     const definition = this.validator.validateToolDefinition(definitionValue, tool.name);
-    return { name: definition.name, path: tool.toolPath, definition };
+    const env = await this.envLoader.load(tool, definition);
+    return { name: definition.name, path: tool.toolPath, env, definition };
   }
   async evaluateModuleDefault(value, toolName) {
     const awaitedValue = await Promise.resolve(value);
@@ -475,15 +539,15 @@ class ToolLoader {
   async loadCommand(toolName, commandName) {
     const tool = await this.load(toolName);
     this.validator.validateCommandName(commandName);
-    const command2 = tool.definition.commands[commandName];
-    if (!command2) {
+    const command = tool.definition.commands[commandName];
+    if (!command) {
       throw new RigError("COMMAND_NOT_FOUND", `Command not found: ${CommandIds.from(toolName, commandName)}`, {
         tool: toolName,
         command: commandName,
         available: Object.keys(tool.definition.commands)
       });
     }
-    return { tool, commandName, command: command2 };
+    return { tool, commandName, command };
   }
 }
 

package/dist/{cli-dshh1cp9.js → cli-f4k31gtc.js}

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

package/dist/{cli-vx11bmzr.js → cli-ggk7t6dg.js}

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