@knid/agentx 0.1.9 → 0.2.0

package/dist/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command19 } from "commander";
-import { readFileSync as readFileSync12 } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname2, join as join17 } from "path";
+import { Command as Command20 } from "commander";
+import { readFileSync as readFileSync16 } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname4, join as join21 } from "path";
 
 // src/commands/run.ts
 import { Command } from "commander";
@@ -20,6 +20,7 @@ import { parse } from "yaml";
 
 // src/schemas/agent-yaml.ts
 import { z } from "zod";
+import { Cron } from "croner";
 var VALID_CATEGORIES = [
   "productivity",
   "devtools",
@@ -63,6 +64,21 @@ var requiresSchema = z.object({
   node: z.string().optional(),
   os: z.array(z.string()).optional()
 });
+var scheduleEntrySchema = z.object({
+  name: z.string().optional(),
+  cron: z.string().refine(
+    (val) => {
+      try {
+        new Cron(val);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    { message: "Invalid cron expression" }
+  ),
+  prompt: z.string().min(1).max(2e3)
+});
 var agentYamlSchema = z.object({
   name: z.string().min(1).max(100).regex(AGENT_NAME_REGEX, "Name must contain only lowercase letters, numbers, and hyphens"),
   version: z.string().regex(SEMVER_REGEX, "Version must be valid semver (e.g. 1.0.0)"),
@@ -79,7 +95,8 @@ var agentYamlSchema = z.object({
   permissions: permissionsSchema.optional(),
   allowed_tools: z.array(z.string()).optional(),
   config: z.array(configOptionSchema).optional(),
-  examples: z.array(exampleSchema).optional()
+  examples: z.array(exampleSchema).optional(),
+  schedule: z.array(scheduleEntrySchema).max(10).optional()
 });
 
 // src/config/paths.ts
@@ -92,6 +109,10 @@ var CONFIG_PATH = join(AGENTX_HOME, "config.yaml");
 var AUTH_PATH = join(AGENTX_HOME, "auth.json");
 var CACHE_DIR = join(AGENTX_HOME, "cache");
 var LOGS_DIR = join(AGENTX_HOME, "logs");
+var SCHEDULER_DIR = join(AGENTX_HOME, "scheduler");
+var SCHEDULER_PID = join(SCHEDULER_DIR, "scheduler.pid");
+var SCHEDULER_STATE = join(SCHEDULER_DIR, "state.json");
+var SCHEDULER_LOGS_DIR = join(SCHEDULER_DIR, "logs");
 
 // src/utils/errors.ts
 var AgentxError = class extends Error {
@@ -502,6 +523,10 @@ async function deleteSecrets(agentName, secretsDir = SECRETS_DIR) {
     unlinkSync(filePath);
   }
 }
+async function hasSecrets(agentName, secretsDir = SECRETS_DIR) {
+  const filePath = getSecretsFilePath(agentName, secretsDir);
+  return existsSync5(filePath);
+}
 
 // src/runtime/runner.ts
 function buildClaudeArgs(options) {
@@ -1628,20 +1653,196 @@ Examples:
 
 // src/commands/uninstall.ts
 import { Command as Command12 } from "commander";
-import { existsSync as existsSync17, rmSync as rmSync2 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync19, rmSync as rmSync2 } from "fs";
+import { join as join16 } from "path";
+
+// src/scheduler/state.ts
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync6, existsSync as existsSync17, mkdirSync as mkdirSync6, renameSync } from "fs";
+import { dirname as dirname2, join as join14 } from "path";
+var EMPTY_STATE = {
+  pid: null,
+  startedAt: null,
+  agents: {}
+};
+async function loadScheduleState(statePath) {
+  if (!existsSync17(statePath)) {
+    return { ...EMPTY_STATE, agents: {} };
+  }
+  const raw = readFileSync12(statePath, "utf-8");
+  return JSON.parse(raw);
+}
+async function saveScheduleState(state, statePath) {
+  const dir = dirname2(statePath);
+  mkdirSync6(dir, { recursive: true });
+  const tmpPath = join14(dir, `.state.${Date.now()}.tmp`);
+  writeFileSync6(tmpPath, JSON.stringify(state, null, 2), { encoding: "utf-8", mode: 384 });
+  renameSync(tmpPath, statePath);
+}
+function addAgentToState(state, agentName, schedules) {
+  const scheduleStates = schedules.map((s) => ({
+    name: s.name ?? s.cron,
+    cron: s.cron,
+    prompt: s.prompt,
+    status: "active",
+    lastRunAt: null,
+    lastRunStatus: null,
+    nextRunAt: null,
+    runCount: 0,
+    errorCount: 0
+  }));
+  return {
+    ...state,
+    agents: {
+      ...state.agents,
+      [agentName]: {
+        agentName,
+        schedules: scheduleStates,
+        registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    }
+  };
+}
+function removeAgentFromState(state, agentName) {
+  const { [agentName]: _, ...remainingAgents } = state.agents;
+  return {
+    ...state,
+    agents: remainingAgents
+  };
+}
+
+// src/scheduler/process.ts
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync7, existsSync as existsSync18, unlinkSync as unlinkSync4, mkdirSync as mkdirSync7 } from "fs";
+import { dirname as dirname3, join as join15 } from "path";
+import { fork } from "child_process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename3 = fileURLToPath2(import.meta.url);
+var __dirname3 = dirname3(__filename3);
+function isDaemonRunning(pidPath) {
+  if (!existsSync18(pidPath)) {
+    return false;
+  }
+  const pid = getDaemonPid(pidPath);
+  if (pid === null) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    unlinkSync4(pidPath);
+    return false;
+  }
+}
+function getDaemonPid(pidPath) {
+  if (!existsSync18(pidPath)) {
+    return null;
+  }
+  const raw = readFileSync13(pidPath, "utf-8").trim();
+  const pid = parseInt(raw, 10);
+  return isNaN(pid) ? null : pid;
+}
+function startDaemon(pidPath, statePath, logsDir) {
+  if (existsSync18(pidPath)) {
+    const pid2 = getDaemonPid(pidPath);
+    if (pid2 !== null) {
+      try {
+        process.kill(pid2, 0);
+        return pid2;
+      } catch {
+        unlinkSync4(pidPath);
+      }
+    }
+  }
+  const dir = dirname3(pidPath);
+  mkdirSync7(dir, { recursive: true });
+  const candidates = [
+    join15(__dirname3, "..", "scheduler", "daemon.js"),
+    // dist/scheduler/daemon.js from dist/index.js
+    join15(__dirname3, "daemon.js"),
+    // same directory
+    join15(__dirname3, "..", "dist", "scheduler", "daemon.js")
+    // from src/ during dev
+  ];
+  let daemonScript = candidates[0];
+  for (const c of candidates) {
+    if (existsSync18(c)) {
+      daemonScript = c;
+      break;
+    }
+  }
+  const child = fork(daemonScript, [], {
+    detached: true,
+    stdio: "ignore",
+    env: {
+      ...process.env,
+      AGENTX_SCHEDULER_STATE: statePath,
+      AGENTX_SCHEDULER_PID: pidPath,
+      AGENTX_SCHEDULER_LOGS: logsDir
+    }
+  });
+  const pid = child.pid;
+  writeFileSync7(pidPath, String(pid), { encoding: "utf-8", mode: 384 });
+  child.unref();
+  return pid;
+}
+function stopDaemon(pidPath) {
+  const pid = getDaemonPid(pidPath);
+  if (pid === null) {
+    return false;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    if (existsSync18(pidPath)) {
+      unlinkSync4(pidPath);
+    }
+    return true;
+  } catch {
+    if (existsSync18(pidPath)) {
+      unlinkSync4(pidPath);
+    }
+    return false;
+  }
+}
+function signalDaemon(signal, pidPath) {
+  const pid = getDaemonPid(pidPath);
+  if (pid === null) {
+    return false;
+  }
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/uninstall.ts
 var uninstallCommand = new Command12("uninstall").description("Uninstall an agent").argument("<agent>", "Agent name to uninstall").option("--keep-secrets", "Keep secrets (do not delete encrypted secrets)").addHelpText("after", `
 Examples:
   $ agentx uninstall data-analyst
   $ agentx uninstall gmail-agent --keep-secrets`).action(async (agentName, options) => {
   try {
-    const agentDir = join14(AGENTS_DIR, agentName);
-    if (!existsSync17(agentDir)) {
+    const agentDir = join16(AGENTS_DIR, agentName);
+    if (!existsSync19(agentDir)) {
       console.error(
         colors.error(`Agent "${agentName}" is not installed.`)
       );
       process.exit(1);
     }
+    try {
+      const state = await loadScheduleState(SCHEDULER_STATE);
+      if (state.agents[agentName]) {
+        const updated = removeAgentFromState(state, agentName);
+        await saveScheduleState(updated, SCHEDULER_STATE);
+        if (Object.keys(updated.agents).length === 0) {
+          stopDaemon(SCHEDULER_PID);
+        } else if (isDaemonRunning(SCHEDULER_PID)) {
+          signalDaemon("SIGHUP", SCHEDULER_PID);
+        }
+        console.log(colors.dim(`Stopped schedule for ${agentName}`));
+      }
+    } catch {
+    }
     rmSync2(agentDir, { recursive: true, force: true });
     if (!options.keepSecrets) {
       await deleteSecrets(agentName);
@@ -1659,8 +1860,8 @@ Examples:
 
 // src/commands/list.ts
 import { Command as Command13 } from "commander";
-import { existsSync as existsSync18, readdirSync } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync20, readdirSync } from "fs";
+import { join as join17 } from "path";
 
 // src/ui/table.ts
 function formatTable(columns, rows) {
@@ -1688,7 +1889,7 @@ Examples:
   $ agentx list
   $ agentx ls --json`).action((options) => {
   try {
-    if (!existsSync18(AGENTS_DIR)) {
+    if (!existsSync20(AGENTS_DIR)) {
       if (options.json) {
         console.log(JSON.stringify([]));
       } else {
@@ -1699,7 +1900,7 @@ Examples:
       }
       return;
     }
-    const entries = readdirSync(AGENTS_DIR, { withFileTypes: true }).filter((e) => e.isDirectory()).filter((e) => existsSync18(join15(AGENTS_DIR, e.name, "agent.yaml")));
+    const entries = readdirSync(AGENTS_DIR, { withFileTypes: true }).filter((e) => e.isDirectory()).filter((e) => existsSync20(join17(AGENTS_DIR, e.name, "agent.yaml")));
     if (entries.length === 0) {
       if (options.json) {
         console.log(JSON.stringify([]));
@@ -1712,7 +1913,7 @@ Examples:
       return;
     }
     const agentData = entries.map((entry) => {
-      const agentDir = join15(AGENTS_DIR, entry.name);
+      const agentDir = join17(AGENTS_DIR, entry.name);
       try {
         const manifest = loadAgentYaml(agentDir);
         return {
@@ -1758,8 +1959,8 @@ Examples:
 
 // src/commands/update.ts
 import { Command as Command14 } from "commander";
-import { existsSync as existsSync19, readdirSync as readdirSync2 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync21, readdirSync as readdirSync2 } from "fs";
+import { join as join18 } from "path";
 
 // src/utils/semver.ts
 var SEMVER_REGEX2 = /^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9.]+))?(?:\+[a-zA-Z0-9.]+)?$/;
@@ -1805,11 +2006,11 @@ Examples:
     }
     const agentsToUpdate = [];
     if (options?.all) {
-      if (!existsSync19(AGENTS_DIR)) {
+      if (!existsSync21(AGENTS_DIR)) {
         console.log(colors.dim("No agents installed."));
         return;
       }
-      const entries = readdirSync2(AGENTS_DIR, { withFileTypes: true }).filter((e) => e.isDirectory()).filter((e) => existsSync19(join16(AGENTS_DIR, e.name, "agent.yaml")));
+      const entries = readdirSync2(AGENTS_DIR, { withFileTypes: true }).filter((e) => e.isDirectory()).filter((e) => existsSync21(join18(AGENTS_DIR, e.name, "agent.yaml")));
       agentsToUpdate.push(...entries.map((e) => e.name));
     } else if (agentName) {
       agentsToUpdate.push(agentName);
@@ -1820,8 +2021,8 @@ Examples:
     }
     let updatedCount = 0;
     for (const name of agentsToUpdate) {
-      const agentDir = join16(AGENTS_DIR, name);
-      if (!existsSync19(agentDir)) {
+      const agentDir = join18(AGENTS_DIR, name);
+      if (!existsSync21(agentDir)) {
         console.log(colors.warn(`Agent "${name}" is not installed. Skipping.`));
         continue;
       }
@@ -2181,11 +2382,289 @@ configCommand.command("reset").description("Reset configuration to defaults").ac
   }
 });
 
+// src/commands/schedule.ts
+import { Command as Command19 } from "commander";
+import { existsSync as existsSync23, readFileSync as readFileSync15 } from "fs";
+import { join as join20 } from "path";
+import { Cron as Cron2 } from "croner";
+
+// src/scheduler/log-store.ts
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync8, existsSync as existsSync22, mkdirSync as mkdirSync8, readdirSync as readdirSync3, unlinkSync as unlinkSync5 } from "fs";
+import { join as join19 } from "path";
+function getAgentLogDir(agentName, logsDir) {
+  return join19(logsDir, agentName);
+}
+async function readLatestLog(agentName, logsDir) {
+  const agentDir = getAgentLogDir(agentName, logsDir);
+  if (!existsSync22(agentDir)) {
+    return null;
+  }
+  const files = readdirSync3(agentDir).filter((f) => f.endsWith(".json")).sort();
+  if (files.length === 0) {
+    return null;
+  }
+  const latest = files[files.length - 1];
+  const raw = readFileSync14(join19(agentDir, latest), "utf-8");
+  return JSON.parse(raw);
+}
+async function readAllLogs(agentName, logsDir) {
+  const agentDir = getAgentLogDir(agentName, logsDir);
+  if (!existsSync22(agentDir)) {
+    return [];
+  }
+  const files = readdirSync3(agentDir).filter((f) => f.endsWith(".json")).sort().reverse();
+  return files.map((f) => JSON.parse(readFileSync14(join19(agentDir, f), "utf-8")));
+}
+
+// src/commands/schedule.ts
+import { parse as parseYaml } from "yaml";
+var scheduleCommand = new Command19("schedule").description("Manage agent schedules").addHelpText("after", `
+Examples:
+  $ agentx schedule start slack-agent
+  $ agentx schedule stop slack-agent
+  $ agentx schedule list
+  $ agentx schedule logs slack-agent
+  $ agentx schedule logs slack-agent --all
+  $ agentx schedule resume`);
+scheduleCommand.command("start").description("Start an agent schedule").argument("<agent>", "Agent name to schedule").addHelpText("after", `
+Examples:
+  $ agentx schedule start slack-agent`).action(async (agentName) => {
+  try {
+    const agentDir = join20(AGENTS_DIR, agentName);
+    const manifestPath = join20(agentDir, "agent.yaml");
+    if (!existsSync23(manifestPath)) {
+      console.error(colors.error(`Error: Agent "${agentName}" is not installed.`));
+      process.exit(1);
+    }
+    const raw = readFileSync15(manifestPath, "utf-8");
+    const parsed = parseYaml(raw);
+    const manifest = agentYamlSchema.parse(parsed);
+    if (!manifest.schedule || manifest.schedule.length === 0) {
+      console.error(colors.error(`Error: ${agentName} has no schedule block in agent.yaml`));
+      process.exit(1);
+    }
+    if (manifest.secrets && manifest.secrets.length > 0) {
+      const requiredSecrets = manifest.secrets.filter((s) => s.required);
+      if (requiredSecrets.length > 0) {
+        const configured = await hasSecrets(agentName);
+        if (!configured) {
+          const names = requiredSecrets.map((s) => s.name).join(", ");
+          console.error(colors.error(`Error: Missing required secrets for ${agentName}: ${names}`));
+          console.error(`Run: agentx configure ${agentName}`);
+          process.exit(1);
+        }
+      }
+    }
+    let state = await loadScheduleState(SCHEDULER_STATE);
+    state = addAgentToState(state, agentName, manifest.schedule);
+    for (const sched of state.agents[agentName].schedules) {
+      try {
+        const cron = new Cron2(sched.cron);
+        const next = cron.nextRun();
+        if (next) {
+          sched.nextRunAt = next.toISOString();
+        }
+      } catch {
+      }
+    }
+    await saveScheduleState(state, SCHEDULER_STATE);
+    if (isDaemonRunning(SCHEDULER_PID)) {
+      signalDaemon("SIGHUP", SCHEDULER_PID);
+    } else {
+      startDaemon(SCHEDULER_PID, SCHEDULER_STATE, SCHEDULER_LOGS_DIR);
+    }
+    console.log(colors.success(`Schedule started for ${colors.bold(agentName)}`));
+    for (const sched of state.agents[agentName].schedules) {
+      const nextStr = sched.nextRunAt ? new Date(sched.nextRunAt).toLocaleString() : "unknown";
+      console.log(`  ${colors.cyan(sched.name)}  ${colors.dim(sched.cron)}  ${colors.dim(`(next: ${nextStr})`)}`);
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+scheduleCommand.command("stop").description("Stop an agent schedule").argument("<agent>", "Agent name to stop").addHelpText("after", `
+Examples:
+  $ agentx schedule stop slack-agent`).action(async (agentName) => {
+  try {
+    let state = await loadScheduleState(SCHEDULER_STATE);
+    if (!state.agents[agentName]) {
+      console.error(colors.error(`Error: ${agentName} has no active schedule`));
+      console.error(`Run: agentx schedule list`);
+      process.exit(1);
+    }
+    state = removeAgentFromState(state, agentName);
+    await saveScheduleState(state, SCHEDULER_STATE);
+    if (Object.keys(state.agents).length === 0) {
+      stopDaemon(SCHEDULER_PID);
+      console.log(colors.success(`Schedule stopped for ${colors.bold(agentName)}`));
+      console.log(colors.dim("Scheduler daemon shut down (no active schedules)"));
+    } else {
+      signalDaemon("SIGHUP", SCHEDULER_PID);
+      console.log(colors.success(`Schedule stopped for ${colors.bold(agentName)}`));
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+scheduleCommand.command("list").description("List all active schedules").addHelpText("after", `
+Examples:
+  $ agentx schedule list`).action(async () => {
+  try {
+    const state = await loadScheduleState(SCHEDULER_STATE);
+    const agents = Object.values(state.agents);
+    if (agents.length === 0) {
+      console.log("No active schedules.");
+      console.log(colors.dim("Start one with: agentx schedule start <agent-name>"));
+      return;
+    }
+    const header = [
+      "Agent".padEnd(20),
+      "Schedule".padEnd(18),
+      "Status".padEnd(10),
+      "Last Run".padEnd(24),
+      "Next Run"
+    ].join("");
+    console.log(colors.bold(header));
+    for (const agent of agents) {
+      for (const sched of agent.schedules) {
+        const lastRun = sched.lastRunAt ? new Date(sched.lastRunAt).toLocaleString() : "-";
+        const nextRun = sched.nextRunAt ? new Date(sched.nextRunAt).toLocaleString() : "-";
+        const statusColor = sched.status === "errored" ? colors.error : sched.status === "running" ? colors.warn : colors.success;
+        const row = [
+          agent.agentName.padEnd(20),
+          sched.cron.padEnd(18),
+          statusColor(sched.status.padEnd(10)),
+          lastRun.padEnd(24),
+          nextRun
+        ].join("");
+        console.log(row);
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+scheduleCommand.command("logs").description("View execution logs for a scheduled agent").argument("<agent>", "Agent name").option("--all", "Show summary of all past runs").addHelpText("after", `
+Examples:
+  $ agentx schedule logs slack-agent
+  $ agentx schedule logs slack-agent --all`).action(async (agentName, options) => {
+  try {
+    if (options.all) {
+      const logs = await readAllLogs(agentName, SCHEDULER_LOGS_DIR);
+      if (logs.length === 0) {
+        console.log(`No runs recorded for ${agentName}.`);
+        return;
+      }
+      const header = [
+        "Time".padEnd(24),
+        "Schedule".padEnd(18),
+        "Status".padEnd(10),
+        "Duration"
+      ].join("");
+      console.log(colors.bold(header));
+      for (const log2 of logs) {
+        const time = new Date(log2.timestamp).toLocaleString();
+        const statusColor = log2.status === "failure" ? colors.error : colors.success;
+        const dur = `${(log2.duration / 1e3).toFixed(1)}s`;
+        const row = [
+          time.padEnd(24),
+          log2.scheduleName.padEnd(18),
+          statusColor(log2.status.padEnd(10)),
+          dur
+        ].join("");
+        console.log(row);
+      }
+    } else {
+      const log2 = await readLatestLog(agentName, SCHEDULER_LOGS_DIR);
+      if (!log2) {
+        console.log(`No runs recorded for ${agentName}.`);
+        return;
+      }
+      const statusColor = log2.status === "failure" ? colors.error : colors.success;
+      console.log(`Last run: ${new Date(log2.timestamp).toLocaleString()} (${log2.scheduleName})`);
+      console.log(`Status:   ${statusColor(log2.status)}`);
+      console.log(`Duration: ${(log2.duration / 1e3).toFixed(1)}s`);
+      console.log(`Prompt:   ${log2.prompt}`);
+      console.log("");
+      if (log2.output) {
+        console.log("Output:");
+        console.log(`  ${log2.output.split("\n").join("\n  ")}`);
+      }
+      if (log2.status === "failure" && log2.error) {
+        console.log("");
+        console.log(colors.error(`Error: ${log2.error}`));
+      }
+      if (log2.stderr) {
+        console.log(colors.dim(`Stderr: ${log2.stderr}`));
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+scheduleCommand.command("resume").description("Resume all previously active schedules").addHelpText("after", `
+Examples:
+  $ agentx schedule resume`).action(async () => {
+  try {
+    const state = await loadScheduleState(SCHEDULER_STATE);
+    const agents = Object.values(state.agents);
+    if (agents.length === 0) {
+      console.log("No schedules to resume.");
+      console.log(colors.dim("Start one with: agentx schedule start <agent-name>"));
+      return;
+    }
+    for (const agent of agents) {
+      for (const sched of agent.schedules) {
+        try {
+          const cron = new Cron2(sched.cron);
+          const next = cron.nextRun();
+          if (next) {
+            sched.nextRunAt = next.toISOString();
+          }
+        } catch {
+        }
+        if (sched.status === "errored") {
+          sched.status = "active";
+        }
+      }
+    }
+    await saveScheduleState(state, SCHEDULER_STATE);
+    if (isDaemonRunning(SCHEDULER_PID)) {
+      signalDaemon("SIGHUP", SCHEDULER_PID);
+      console.log(colors.success("Scheduler daemon reloaded."));
+    } else {
+      startDaemon(SCHEDULER_PID, SCHEDULER_STATE, SCHEDULER_LOGS_DIR);
+      console.log(colors.success("Scheduler daemon started."));
+    }
+    console.log(`Resumed ${agents.length} agent(s):`);
+    for (const agent of agents) {
+      console.log(`  ${colors.cyan(agent.agentName)} (${agent.schedules.length} schedule(s))`);
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+
 // src/index.ts
-var __filename3 = fileURLToPath2(import.meta.url);
-var __dirname3 = dirname2(__filename3);
-var pkg = JSON.parse(readFileSync12(join17(__dirname3, "..", "package.json"), "utf-8"));
-var program = new Command19();
+var __filename4 = fileURLToPath3(import.meta.url);
+var __dirname4 = dirname4(__filename4);
+var pkg = JSON.parse(readFileSync16(join21(__dirname4, "..", "package.json"), "utf-8"));
+var program = new Command20();
 program.name("agentx").description("The package manager for AI agents powered by Claude Code").version(pkg.version).option("--verbose", "Show verbose output").option("--debug", "Show debug output including stack traces").hook("preAction", (_thisCommand, actionCommand) => {
   const opts = program.opts();
   if (opts.verbose) {
@@ -2214,6 +2693,7 @@ program.addCommand(infoCommand);
 program.addCommand(searchCommand);
 program.addCommand(trendingCommand);
 program.addCommand(configCommand);
+program.addCommand(scheduleCommand);
 program.parse();
 export {
   program

package/dist/scheduler/daemon.js

@@ -0,0 +1,233 @@
+// src/scheduler/daemon.ts
+import { Cron } from "croner";
+
+// src/scheduler/state.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from "fs";
+import { dirname, join } from "path";
+var EMPTY_STATE = {
+  pid: null,
+  startedAt: null,
+  agents: {}
+};
+async function loadScheduleState(statePath2) {
+  if (!existsSync(statePath2)) {
+    return { ...EMPTY_STATE, agents: {} };
+  }
+  const raw = readFileSync(statePath2, "utf-8");
+  return JSON.parse(raw);
+}
+async function saveScheduleState(state, statePath2) {
+  const dir = dirname(statePath2);
+  mkdirSync(dir, { recursive: true });
+  const tmpPath = join(dir, `.state.${Date.now()}.tmp`);
+  writeFileSync(tmpPath, JSON.stringify(state, null, 2), { encoding: "utf-8", mode: 384 });
+  renameSync(tmpPath, statePath2);
+}
+
+// src/scheduler/log-store.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, unlinkSync } from "fs";
+import { join as join2 } from "path";
+var MAX_LOG_FILES = 50;
+function getAgentLogDir(agentName, logsDir2) {
+  return join2(logsDir2, agentName);
+}
+function timestampToFilename(timestamp) {
+  return timestamp.replace(/:/g, "-") + ".json";
+}
+async function writeRunLog(log, logsDir2) {
+  const agentDir = getAgentLogDir(log.agentName, logsDir2);
+  mkdirSync2(agentDir, { recursive: true });
+  const filename = timestampToFilename(log.timestamp);
+  const filePath = join2(agentDir, filename);
+  writeFileSync2(filePath, JSON.stringify(log, null, 2), "utf-8");
+}
+async function rotateLogs(agentName, logsDir2) {
+  const agentDir = getAgentLogDir(agentName, logsDir2);
+  if (!existsSync2(agentDir)) {
+    return;
+  }
+  const files = readdirSync(agentDir).filter((f) => f.endsWith(".json")).sort();
+  if (files.length <= MAX_LOG_FILES) {
+    return;
+  }
+  const toDelete = files.slice(0, files.length - MAX_LOG_FILES);
+  for (const f of toDelete) {
+    unlinkSync(join2(agentDir, f));
+  }
+}
+
+// src/scheduler/daemon.ts
+import { writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, existsSync as existsSync3 } from "fs";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var statePath = process.env.AGENTX_SCHEDULER_STATE;
+var pidPath = process.env.AGENTX_SCHEDULER_PID;
+var logsDir = process.env.AGENTX_SCHEDULER_LOGS;
+var activeJobs = /* @__PURE__ */ new Map();
+var runningAgents = /* @__PURE__ */ new Set();
+var RETRY_DELAYS = [1e4, 3e4];
+async function executeAgent(agentName, schedule, retryAttempt = 0) {
+  const runKey = `${agentName}:${schedule.name}`;
+  if (runningAgents.has(runKey)) {
+    await writeRunLog({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      agentName,
+      scheduleName: schedule.name,
+      cron: schedule.cron,
+      prompt: schedule.prompt,
+      output: "",
+      stderr: "",
+      status: "success",
+      duration: 0,
+      error: null,
+      retryAttempt,
+      skipped: true
+    }, logsDir);
+    return;
+  }
+  runningAgents.add(runKey);
+  const startTime = Date.now();
+  const state = await loadScheduleState(statePath);
+  const agentState = state.agents[agentName];
+  if (agentState) {
+    const schedState = agentState.schedules.find((s) => s.name === schedule.name);
+    if (schedState) {
+      schedState.status = "running";
+      await saveScheduleState(state, statePath);
+    }
+  }
+  try {
+    const { stdout, stderr } = await execFileAsync("agentx", ["run", agentName, schedule.prompt], {
+      timeout: 3e5,
+      // 5 minute timeout
+      env: { ...process.env }
+    });
+    const duration = Date.now() - startTime;
+    await writeRunLog({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      agentName,
+      scheduleName: schedule.name,
+      cron: schedule.cron,
+      prompt: schedule.prompt,
+      output: stdout,
+      stderr: stderr || "",
+      status: "success",
+      duration,
+      error: null,
+      retryAttempt,
+      skipped: false
+    }, logsDir);
+    const updatedState = await loadScheduleState(statePath);
+    const updAgent = updatedState.agents[agentName];
+    if (updAgent) {
+      const sched = updAgent.schedules.find((s) => s.name === schedule.name);
+      if (sched) {
+        sched.status = "active";
+        sched.lastRunAt = (/* @__PURE__ */ new Date()).toISOString();
+        sched.lastRunStatus = "success";
+        sched.runCount += 1;
+        await saveScheduleState(updatedState, statePath);
+      }
+    }
+    await rotateLogs(agentName, logsDir);
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    const errMsg = error instanceof Error ? error.message : String(error);
+    const stderr = error && typeof error === "object" && "stderr" in error ? String(error.stderr) : "";
+    await writeRunLog({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      agentName,
+      scheduleName: schedule.name,
+      cron: schedule.cron,
+      prompt: schedule.prompt,
+      output: "",
+      stderr,
+      status: "failure",
+      duration,
+      error: errMsg,
+      retryAttempt,
+      skipped: false
+    }, logsDir);
+    if (retryAttempt < RETRY_DELAYS.length) {
+      runningAgents.delete(runKey);
+      const delay = RETRY_DELAYS[retryAttempt];
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      return executeAgent(agentName, schedule, retryAttempt + 1);
+    }
+    const updatedState = await loadScheduleState(statePath);
+    const updAgent = updatedState.agents[agentName];
+    if (updAgent) {
+      const sched = updAgent.schedules.find((s) => s.name === schedule.name);
+      if (sched) {
+        sched.status = "errored";
+        sched.lastRunAt = (/* @__PURE__ */ new Date()).toISOString();
+        sched.lastRunStatus = "failure";
+        sched.runCount += 1;
+        sched.errorCount += 1;
+        await saveScheduleState(updatedState, statePath);
+      }
+    }
+    await rotateLogs(agentName, logsDir);
+  } finally {
+    runningAgents.delete(runKey);
+  }
+}
+function reconcileJobs(state) {
+  for (const [, jobs] of activeJobs) {
+    for (const job of jobs) {
+      job.stop();
+    }
+  }
+  activeJobs.clear();
+  for (const [agentName, agentState] of Object.entries(state.agents)) {
+    const jobs = [];
+    for (const schedule of agentState.schedules) {
+      const job = new Cron(schedule.cron, () => {
+        executeAgent(agentName, schedule).catch((err) => {
+          console.error(`[scheduler] Error executing ${agentName}/${schedule.name}:`, err);
+        });
+      });
+      const nextRun = job.nextRun();
+      if (nextRun) {
+        schedule.nextRunAt = nextRun.toISOString();
+      }
+      jobs.push(job);
+    }
+    activeJobs.set(agentName, jobs);
+  }
+  saveScheduleState(state, statePath).catch(() => {
+  });
+}
+async function startup() {
+  writeFileSync3(pidPath, String(process.pid), { encoding: "utf-8", mode: 384 });
+  const state = await loadScheduleState(statePath);
+  state.pid = process.pid;
+  state.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveScheduleState(state, statePath);
+  reconcileJobs(state);
+}
+process.on("SIGHUP", async () => {
+  try {
+    const state = await loadScheduleState(statePath);
+    reconcileJobs(state);
+  } catch (err) {
+    console.error("[scheduler] Error handling SIGHUP:", err);
+  }
+});
+process.on("SIGTERM", () => {
+  for (const [, jobs] of activeJobs) {
+    for (const job of jobs) {
+      job.stop();
+    }
+  }
+  activeJobs.clear();
+  if (existsSync3(pidPath)) {
+    unlinkSync2(pidPath);
+  }
+  process.exit(0);
+});
+startup().catch((err) => {
+  console.error("[scheduler] Fatal startup error:", err);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knid/agentx",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "description": "The package manager for AI agents powered by Claude Code",
   "type": "module",
   "bin": {
@@ -28,6 +28,7 @@
     "@clack/prompts": "^0.9.0",
     "chalk": "^5.4.0",
     "commander": "^12.0.0",
+    "croner": "^10.0.1",
     "execa": "^9.0.0",
     "marked": "^15.0.12",
     "marked-terminal": "^7.3.0",