@tuttiai/cli 0.11.0 → 0.12.0

package/README.md

@@ -231,6 +231,96 @@ Resume from turn 2? (y/n) y
   Final turn:    3
 ```
 
+### `tutti-ai schedule [score]`
+
+Start the scheduler daemon — reads a score file, registers all agents
+that have a `schedule` config, and runs on their configured triggers
+(cron, interval, or one-shot datetime) until the process is killed.
+
+```bash
+tutti-ai schedule                     # defaults to ./tutti.score.ts
+tutti-ai schedule ./custom-score.ts   # specify a score file
+```
+
+Score file example:
+
+```ts
+const score = defineScore({
+  provider: new AnthropicProvider(),
+  agents: {
+    reporter: {
+      name: "Reporter",
+      system_prompt: "Generate a daily status report.",
+      voices: [],
+      schedule: {
+        cron: "0 9 * * *",           // 9 AM daily
+        input: "Generate the daily status report",
+        max_runs: 30,                 // auto-disable after 30 runs
+      },
+    },
+  },
+});
+```
+
+Environment:
+
+| Variable | Required | Description |
+|---|---|---|
+| `TUTTI_PG_URL` | Recommended | PostgreSQL URL for durable schedule persistence. Falls back to in-memory (lost on restart). |
+
+The daemon logs `schedule:triggered`, `schedule:completed`, and
+`schedule:error` events to stdout with timestamps.
+
+### `tutti-ai schedules list`
+
+Show all registered schedules:
+
+```bash
+tutti-ai schedules list
+```
+
+Output:
+
+```
+  ID                  AGENT           TRIGGER               ENABLED   RUNS    CREATED
+  ──────────────────────────────────────────────────────────────────────────────────────
+  nightly-report      reporter        cron: 0 9 * * *       yes       12      2026-04-14
+  health-check        monitor         every 30m             yes       48/100  2026-04-14
+```
+
+### `tutti-ai schedules enable <id>`
+
+Re-enable a disabled schedule:
+
+```bash
+tutti-ai schedules enable nightly-report
+```
+
+### `tutti-ai schedules disable <id>`
+
+Disable a schedule without deleting it:
+
+```bash
+tutti-ai schedules disable nightly-report
+```
+
+### `tutti-ai schedules trigger <id>`
+
+Manually trigger a scheduled run immediately (useful for testing):
+
+```bash
+tutti-ai schedules trigger nightly-report
+tutti-ai schedules trigger nightly-report --score ./custom-score.ts
+```
+
+### `tutti-ai schedules runs <id>`
+
+Show run history for a schedule (last 20 runs):
+
+```bash
+tutti-ai schedules runs nightly-report
+```
+
 ## Links
 
 - [Tutti](https://tutti-ai.com)

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { config } from "dotenv";
-import { createLogger as createLogger11 } from "@tuttiai/core";
+import { createLogger as createLogger13 } from "@tuttiai/core";
 import { Command } from "commander";
 
 // src/commands/init.ts
@@ -1782,22 +1782,24 @@ async function serveCommand(scorePath, options = {}) {
     reactive.on("file-change", () => {
       console.log(chalk10.cyan("\n[tutti] Score changed, reloading..."));
     });
-    reactive.on("reloaded", async () => {
-      try {
-        const nextScore = reactive.current;
-        const nextRuntime = buildRuntime2(nextScore, sharedSessions);
-        const nextApp = await buildApp(nextRuntime, agentName, port, host, options.apiKey);
-        await app.close();
-        runtime = nextRuntime;
-        app = nextApp;
-        await app.listen({ port, host });
-        console.log(chalk10.green("[tutti] Score reloaded. Server restarted."));
-      } catch (err) {
-        logger10.error(
-          { error: err instanceof Error ? err.message : String(err) },
-          "[tutti] Reload failed \u2014 server continues with previous config"
-        );
-      }
+    reactive.on("reloaded", () => {
+      void (async () => {
+        try {
+          const nextScore = reactive.current;
+          const nextRuntime = buildRuntime2(nextScore, sharedSessions);
+          const nextApp = await buildApp(nextRuntime, agentName, port, host, options.apiKey);
+          await app.close();
+          runtime = nextRuntime;
+          app = nextApp;
+          await app.listen({ port, host });
+          console.log(chalk10.green("[tutti] Score reloaded. Server restarted."));
+        } catch (err) {
+          logger10.error(
+            { error: err instanceof Error ? err.message : String(err) },
+            "[tutti] Reload failed \u2014 server continues with previous config"
+          );
+        }
+      })();
     });
     reactive.on("reload-failed", (err) => {
       logger10.error(
@@ -1863,19 +1865,287 @@ function printBanner(port, host, agentName, score, file, watch) {
   console.log();
 }
 
+// src/commands/schedule.ts
+import { existsSync as existsSync11 } from "fs";
+import { resolve as resolve11 } from "path";
+import chalk11 from "chalk";
+import {
+  ScoreLoader as ScoreLoader7,
+  SchedulerEngine,
+  PostgresScheduleStore,
+  MemoryScheduleStore,
+  AgentRunner,
+  EventBus,
+  InMemorySessionStore as InMemorySessionStore3,
+  SecretsManager as SecretsManager6,
+  createLogger as createLogger11
+} from "@tuttiai/core";
+var logger11 = createLogger11("tutti-cli");
+function resolveStore() {
+  const pgUrl = SecretsManager6.optional("TUTTI_PG_URL");
+  if (pgUrl) {
+    return new PostgresScheduleStore({ connection_string: pgUrl });
+  }
+  logger11.warn("TUTTI_PG_URL not set \u2014 using in-memory store (not durable across restarts)");
+  return new MemoryScheduleStore();
+}
+async function scheduleCommand(scorePath) {
+  const file = resolve11(scorePath ?? "./tutti.score.ts");
+  if (!existsSync11(file)) {
+    console.error(chalk11.red("Score file not found: " + file));
+    console.error(chalk11.dim('Run "tutti-ai init" to create a new project.'));
+    process.exit(1);
+  }
+  const score = await ScoreLoader7.load(file);
+  const events = new EventBus();
+  const sessions = new InMemorySessionStore3();
+  const runner = new AgentRunner(
+    score.provider,
+    events,
+    sessions
+  );
+  const store = resolveStore();
+  const engine = new SchedulerEngine(store, runner, events);
+  let registered = 0;
+  for (const [agentId, agent] of Object.entries(score.agents)) {
+    if (!agent.schedule) continue;
+    const resolvedAgent = agent.model ? agent : { ...agent, model: score.default_model ?? "claude-sonnet-4-20250514" };
+    await engine.schedule(agentId, resolvedAgent, agent.schedule);
+    registered++;
+  }
+  if (registered === 0) {
+    console.log(chalk11.yellow("No agents have a schedule config. Nothing to run."));
+    console.log(chalk11.dim("Add schedule: { cron: '...', input: '...' } to an agent in your score."));
+    process.exit(0);
+  }
+  events.onAny((e) => {
+    if (e.type === "schedule:triggered") {
+      const ev = e;
+      console.log(
+        chalk11.dim((/* @__PURE__ */ new Date()).toISOString()) + " " + chalk11.cyan("triggered") + " " + chalk11.bold(ev.schedule_id) + " \u2192 " + ev.agent_name
+      );
+    }
+    if (e.type === "schedule:completed") {
+      const ev = e;
+      console.log(
+        chalk11.dim((/* @__PURE__ */ new Date()).toISOString()) + " " + chalk11.green("completed") + " " + chalk11.bold(ev.schedule_id) + " " + chalk11.dim("(" + ev.duration_ms + "ms)")
+      );
+    }
+    if (e.type === "schedule:error") {
+      const ev = e;
+      console.log(
+        chalk11.dim((/* @__PURE__ */ new Date()).toISOString()) + " " + chalk11.red("error") + " " + chalk11.bold(ev.schedule_id) + " \u2014 " + ev.error.message
+      );
+    }
+  });
+  engine.start();
+  console.log("");
+  console.log(chalk11.cyan.bold("  Tutti Scheduler"));
+  console.log(chalk11.dim("  Score: " + (score.name ?? file)));
+  console.log(chalk11.dim("  Schedules: " + registered));
+  console.log(chalk11.dim("  Store: " + (SecretsManager6.optional("TUTTI_PG_URL") ? "postgres" : "memory")));
+  console.log("");
+  console.log(chalk11.dim("  Press Ctrl+C to stop."));
+  console.log("");
+  const shutdown = () => {
+    console.log(chalk11.dim("\n  Shutting down scheduler..."));
+    engine.stop();
+    if ("close" in store && typeof store.close === "function") {
+      void store.close();
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await new Promise(() => void 0);
+}
+
+// src/commands/schedules.ts
+import { existsSync as existsSync12 } from "fs";
+import { resolve as resolve12 } from "path";
+import chalk12 from "chalk";
+import {
+  ScoreLoader as ScoreLoader8,
+  SchedulerEngine as SchedulerEngine2,
+  PostgresScheduleStore as PostgresScheduleStore2,
+  MemoryScheduleStore as MemoryScheduleStore2,
+  AgentRunner as AgentRunner2,
+  EventBus as EventBus2,
+  InMemorySessionStore as InMemorySessionStore4,
+  SecretsManager as SecretsManager7,
+  createLogger as createLogger12
+} from "@tuttiai/core";
+var logger12 = createLogger12("tutti-cli");
+function resolveStore2() {
+  const pgUrl = SecretsManager7.optional("TUTTI_PG_URL");
+  if (pgUrl) {
+    return new PostgresScheduleStore2({ connection_string: pgUrl });
+  }
+  logger12.warn("TUTTI_PG_URL not set \u2014 using in-memory store (schedules are ephemeral)");
+  return new MemoryScheduleStore2();
+}
+async function closeStore(store) {
+  if ("close" in store && typeof store.close === "function") {
+    await store.close();
+  }
+}
+function formatTrigger(r) {
+  if (r.config.cron) return "cron: " + r.config.cron;
+  if (r.config.every) return "every " + r.config.every;
+  if (r.config.at) return "at " + r.config.at;
+  return "?";
+}
+function pad(s, len) {
+  return s.length >= len ? s : s + " ".repeat(len - s.length);
+}
+async function schedulesListCommand() {
+  const store = resolveStore2();
+  try {
+    const records = await store.list();
+    if (records.length === 0) {
+      console.log(chalk12.dim("No schedules found."));
+      console.log(chalk12.dim('Run "tutti-ai schedule" to start the scheduler daemon.'));
+      return;
+    }
+    console.log("");
+    console.log(
+      chalk12.dim(
+        "  " + pad("ID", 20) + pad("AGENT", 16) + pad("TRIGGER", 22) + pad("ENABLED", 10) + pad("RUNS", 8) + "CREATED"
+      )
+    );
+    console.log(chalk12.dim("  " + "\u2500".repeat(90)));
+    for (const r of records) {
+      const enabled = r.enabled ? chalk12.green("yes") : chalk12.red("no") + " ";
+      const maxLabel = r.config.max_runs ? r.run_count + "/" + r.config.max_runs : String(r.run_count);
+      console.log(
+        "  " + chalk12.bold(pad(r.id, 20)) + pad(r.agent_id, 16) + pad(formatTrigger(r), 22) + pad(enabled, 10) + pad(maxLabel, 8) + chalk12.dim(r.created_at.toISOString().slice(0, 10))
+      );
+    }
+    console.log("");
+  } finally {
+    await closeStore(store);
+  }
+}
+async function schedulesEnableCommand(id) {
+  const store = resolveStore2();
+  try {
+    const record = await store.get(id);
+    if (!record) {
+      console.error(chalk12.red('Schedule "' + id + '" not found.'));
+      process.exit(1);
+    }
+    await store.setEnabled(id, true);
+    console.log(chalk12.green('Schedule "' + id + '" enabled.'));
+  } finally {
+    await closeStore(store);
+  }
+}
+async function schedulesDisableCommand(id) {
+  const store = resolveStore2();
+  try {
+    const record = await store.get(id);
+    if (!record) {
+      console.error(chalk12.red('Schedule "' + id + '" not found.'));
+      process.exit(1);
+    }
+    await store.setEnabled(id, false);
+    console.log(chalk12.yellow('Schedule "' + id + '" disabled.'));
+  } finally {
+    await closeStore(store);
+  }
+}
+async function schedulesTriggerCommand(id, scorePath) {
+  const file = resolve12(scorePath ?? "./tutti.score.ts");
+  if (!existsSync12(file)) {
+    console.error(chalk12.red("Score file not found: " + file));
+    process.exit(1);
+  }
+  const score = await ScoreLoader8.load(file);
+  const events = new EventBus2();
+  const sessions = new InMemorySessionStore4();
+  const runner = new AgentRunner2(score.provider, events, sessions);
+  const store = resolveStore2();
+  try {
+    const record = await store.get(id);
+    if (!record) {
+      console.error(chalk12.red('Schedule "' + id + '" not found.'));
+      process.exit(1);
+    }
+    const agent = score.agents[record.agent_id];
+    if (!agent) {
+      console.error(chalk12.red('Agent "' + record.agent_id + '" not found in score.'));
+      process.exit(1);
+    }
+    const resolvedAgent = agent.model ? agent : { ...agent, model: score.default_model ?? "claude-sonnet-4-20250514" };
+    const engine = new SchedulerEngine2(store, runner, events);
+    await engine.schedule(id, resolvedAgent, record.config);
+    engine.start();
+    console.log(chalk12.cyan('Triggering "' + id + '" (' + record.agent_id + ")..."));
+    const run2 = await engine.trigger(id);
+    engine.stop();
+    if (run2.error) {
+      console.log(chalk12.red("  Error: " + run2.error));
+      process.exit(1);
+    }
+    const duration = run2.completed_at && run2.triggered_at ? run2.completed_at.getTime() - run2.triggered_at.getTime() : 0;
+    console.log(chalk12.green("  Completed in " + duration + "ms"));
+    if (run2.result) {
+      const preview = run2.result.length > 200 ? run2.result.slice(0, 200) + "..." : run2.result;
+      console.log(chalk12.dim("  Output: " + preview));
+    }
+  } finally {
+    await closeStore(store);
+  }
+}
+async function schedulesRunsCommand(id) {
+  const store = resolveStore2();
+  try {
+    const record = await store.get(id);
+    if (!record) {
+      console.error(chalk12.red('Schedule "' + id + '" not found.'));
+      process.exit(1);
+    }
+    if ("getRuns" in store && typeof store.getRuns === "function") {
+      const runs = store.getRuns(id);
+      if (runs.length === 0) {
+        console.log(chalk12.dim("No runs recorded for this schedule."));
+        return;
+      }
+      const recent = runs.slice(-20);
+      console.log("");
+      console.log(chalk12.dim("  Showing last " + recent.length + " of " + runs.length + " runs:"));
+      console.log("");
+      for (const run2 of recent) {
+        const duration = run2.completed_at && run2.triggered_at ? run2.completed_at.getTime() - run2.triggered_at.getTime() + "ms" : "?";
+        const status = run2.error ? chalk12.red("error") : chalk12.green("ok");
+        const preview = run2.error ? run2.error.slice(0, 80) : (run2.result ?? "").slice(0, 80);
+        console.log(
+          "  " + chalk12.dim(run2.triggered_at.toISOString()) + "  " + status + "  " + chalk12.dim(duration) + "  " + preview
+        );
+      }
+      console.log("");
+    } else {
+      console.log(chalk12.dim('Schedule "' + id + '" has completed ' + record.run_count + " runs."));
+      console.log(chalk12.dim("Full run history requires the MemoryScheduleStore or a future tutti_schedule_runs table."));
+    }
+  } finally {
+    await closeStore(store);
+  }
+}
+
 // src/index.ts
 config();
-var logger11 = createLogger11("tutti-cli");
+var logger13 = createLogger13("tutti-cli");
 process.on("unhandledRejection", (reason) => {
-  logger11.error({ error: reason instanceof Error ? reason.message : String(reason) }, "Unhandled rejection");
+  logger13.error({ error: reason instanceof Error ? reason.message : String(reason) }, "Unhandled rejection");
   process.exit(1);
 });
 process.on("uncaughtException", (err) => {
-  logger11.error({ error: err.message }, "Fatal error");
+  logger13.error({ error: err.message }, "Fatal error");
   process.exit(1);
 });
 var program = new Command();
-program.name("tutti-ai").description("Tutti \u2014 multi-agent orchestration. All agents. All together.").version("0.11.0");
+program.name("tutti-ai").description("Tutti \u2014 multi-agent orchestration. All agents. All together.").version("0.12.0");
 program.command("init [project-name]").description("Create a new Tutti project").option("-t, --template <id>", "Project template to use").action(async (projectName, opts) => {
   await initCommand(projectName, opts.template);
 });
@@ -1931,5 +2201,24 @@ program.command("publish").description("Publish the current voice to npm and the
 program.command("eval <suite-file>").description("Run an evaluation suite against a score").option("--ci", "Exit with code 1 if any case fails").option("-s, --score <path>", "Path to score file (default: ./tutti.score.ts)").action(async (suitePath, opts) => {
   await evalCommand(suitePath, opts);
 });
+program.command("schedule [score]").description("Start the scheduler daemon \u2014 runs agents on their configured schedules").action(async (score) => {
+  await scheduleCommand(score);
+});
+var schedulesCmd = program.command("schedules").description("Manage scheduled agents");
+schedulesCmd.command("list").description("Show all registered schedules").action(async () => {
+  await schedulesListCommand();
+});
+schedulesCmd.command("enable <id>").description("Enable a disabled schedule").action(async (id) => {
+  await schedulesEnableCommand(id);
+});
+schedulesCmd.command("disable <id>").description("Disable a schedule without deleting it").action(async (id) => {
+  await schedulesDisableCommand(id);
+});
+schedulesCmd.command("trigger <id>").description("Manually trigger a scheduled run immediately").option("-s, --score <path>", "Path to score file (default: ./tutti.score.ts)").action(async (id, opts) => {
+  await schedulesTriggerCommand(id, opts.score);
+});
+schedulesCmd.command("runs <id>").description("Show run history for a schedule (last 20 runs)").action(async (id) => {
+  await schedulesRunsCommand(id);
+});
 program.parse();
 //# sourceMappingURL=index.js.map