cronies-cli 0.1.0

package/dist/cronies.js

@@ -0,0 +1,331 @@
+#!/usr/bin/env node
+import {
+  ClaudeCodeAdapter,
+  CodexCliAdapter,
+  CursorAgentAdapter,
+  GeminiCliAdapter,
+  createLogger,
+  getDefaultConfigPath,
+  isDaemonRunning,
+  loadConfig,
+  readPidFile,
+  removePidFile,
+  resolveDataDir,
+  startDaemon,
+  writeConfigToken
+} from "./chunk-FVB2S2MS.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+import { mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { stringify as toYaml } from "yaml";
+var AGENT_LABELS = {
+  "claude-code": "Claude Code",
+  "codex-cli": "Codex",
+  "gemini-cli": "Gemini",
+  "cursor-agent": "Cursor Agent"
+};
+async function runAgentAuthPreFlight() {
+  const adapters = [
+    new ClaudeCodeAdapter(),
+    new CodexCliAdapter(),
+    new GeminiCliAdapter(),
+    new CursorAgentAdapter()
+  ];
+  console.log("");
+  console.log("Checking agents...");
+  const results = await Promise.allSettled(
+    adapters.map(async (adapter) => {
+      const available = await adapter.isAvailable();
+      if (!available) return { adapter, available: false };
+      const auth = await adapter.checkAuth({ skipAvailabilityCheck: true });
+      return { adapter, available: true, auth };
+    })
+  );
+  let readyCount = 0;
+  let installedCount = 0;
+  const needsAuth = [];
+  for (const result of results) {
+    if (result.status === "rejected") continue;
+    const { adapter, available } = result.value;
+    const label = AGENT_LABELS[adapter.name] ?? adapter.name;
+    if (!available) {
+      console.log(`  ${label}: not installed`);
+      continue;
+    }
+    installedCount++;
+    const authResult = result.value.auth;
+    switch (authResult.status) {
+      case "authenticated":
+        console.log(`  ${label}: \u2713 authenticated`);
+        readyCount++;
+        break;
+      case "needs_auth":
+        console.log(`  ${label}: \u2717 needs authentication`);
+        if (authResult.authCommand) {
+          console.log(`    \u2192 Run: ${authResult.authCommand}`);
+        }
+        needsAuth.push({ name: adapter.name, label, authCommand: authResult.authCommand });
+        break;
+      case "error":
+        console.log(`  ${label}: ? error (${authResult.error ?? "unknown"})`);
+        readyCount++;
+        break;
+      default:
+        break;
+    }
+  }
+  if (needsAuth.length > 0) {
+    console.log("");
+    for (const agent of needsAuth) {
+      if (!agent.authCommand) continue;
+      console.log(`  Running auth for ${agent.label}...`);
+      try {
+        const { execSync } = await import("child_process");
+        execSync(agent.authCommand, { stdio: "inherit", timeout: 12e4 });
+        const adapter = adapters.find((a) => a.name === agent.name);
+        if (adapter) {
+          const recheck = await adapter.checkAuth();
+          if (recheck.status === "authenticated") {
+            console.log(`  ${agent.label}: \u2713 authenticated`);
+            readyCount++;
+          } else {
+            console.log(`  ${agent.label}: still needs authentication`);
+          }
+        }
+      } catch {
+        console.log(`  ${agent.label}: auth command failed or timed out`);
+      }
+    }
+  }
+  console.log("");
+  if (readyCount === 0 && installedCount === 0) {
+    console.log("  No agents installed. Install at least one:");
+    console.log("    Claude Code: npm install -g @anthropic-ai/claude-code");
+    console.log("    Codex:       npm install -g @openai/codex");
+    console.log("    Gemini:      npm install -g @google/gemini-cli");
+    console.log("");
+  } else if (readyCount === 0) {
+    console.log(`  ${installedCount} agent(s) installed but none authenticated.`);
+    console.log("  The daemon will start but sessions may fail until agents are authenticated.");
+    console.log("");
+  } else {
+    console.log(`  ${readyCount} agent(s) ready.`);
+    console.log("");
+  }
+}
+var program = new Command().name("cronies").description("The outcome and coordination layer for autonomous engineering work").version("0.1.0");
+program.command("start").description("Start the Cronies daemon").option("-f, --foreground", "Run in foreground (don't daemonize)").option("-p, --port <port>", "API port", "7890").option("-c, --config <path>", "Config file path").option("--skip-auth-check", "Skip agent authentication pre-flight check").action(async (options) => {
+  const config = loadConfig(options.config);
+  const port = Number.parseInt(options.port, 10);
+  if (!Number.isNaN(port)) {
+    config.daemon.port = port;
+  }
+  const dataDir = resolveDataDir(config);
+  if (isDaemonRunning(dataDir)) {
+    const pid = readPidFile(dataDir);
+    console.error(`Cronies daemon is already running (PID ${pid}).`);
+    process.exit(1);
+  }
+  if (!options.skipAuthCheck) {
+    await runAgentAuthPreFlight();
+  }
+  const logger = createLogger(config.daemon.logLevel);
+  if (!options.foreground) {
+    logger.warn("Background mode not yet implemented, running in foreground.");
+  }
+  await startDaemon(config, logger);
+});
+program.command("stop").description("Stop the running daemon").option("-c, --config <path>", "Config file path").action(async (options) => {
+  const config = loadConfig(options.config);
+  const dataDir = resolveDataDir(config);
+  const pid = readPidFile(dataDir);
+  if (pid === null) {
+    console.error("No daemon PID file found. Is the daemon running?");
+    process.exit(1);
+  }
+  if (!isDaemonRunning(dataDir)) {
+    console.log("Daemon is not running. Cleaning up stale PID file.");
+    removePidFile(dataDir);
+    return;
+  }
+  console.log(`Sending SIGTERM to daemon (PID ${pid})...`);
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    console.error(`Failed to send SIGTERM to PID ${pid}.`);
+    process.exit(1);
+  }
+  const deadline = Date.now() + 5e3;
+  const poll = () => new Promise((resolve) => {
+    const check = () => {
+      if (!isDaemonRunning(dataDir)) {
+        resolve();
+        return;
+      }
+      if (Date.now() >= deadline) {
+        console.log("Daemon did not stop in time. Sending SIGKILL...");
+        try {
+          process.kill(pid, "SIGKILL");
+        } catch {
+        }
+        resolve();
+        return;
+      }
+      setTimeout(check, 250);
+    };
+    check();
+  });
+  await poll();
+  removePidFile(dataDir);
+  console.log("Daemon stopped.");
+});
+program.command("status").description("Show daemon status").option("-c, --config <path>", "Config file path").action(async (options) => {
+  const config = loadConfig(options.config);
+  const dataDir = resolveDataDir(config);
+  const pid = readPidFile(dataDir);
+  if (pid === null || !isDaemonRunning(dataDir)) {
+    console.log("Status:  stopped");
+    if (pid !== null) {
+      console.log(`(Stale PID file for PID ${pid} exists. Run "cronies stop" to clean up.)`);
+    }
+    return;
+  }
+  console.log(`Status:  running`);
+  console.log(`PID:     ${pid}`);
+  console.log(`Port:    ${config.daemon.port}`);
+  console.log(`Data:    ${dataDir}`);
+  console.log(`Cloud:   ${config.cloud.token ? "connected" : "not connected (no token)"}`);
+});
+program.command("login").description("Authenticate with Cronies cloud").option("-c, --config <path>", "Config file path").option("--cloud-url <url>", "Cloud dashboard URL").action(async (options) => {
+  const config = loadConfig(options.config);
+  const cloudUrl = (options.cloudUrl ?? config.cloud.url).replace(/\/$/, "");
+  console.log(`Connecting to ${cloudUrl}...`);
+  let deviceCode;
+  try {
+    const res = await fetch(`${cloudUrl}/api/auth/device`, { method: "POST" });
+    if (!res.ok) {
+      console.error(`Failed to initiate login (HTTP ${res.status}). Is the cloud URL correct?`);
+      process.exit(1);
+    }
+    const data = await res.json();
+    deviceCode = data.deviceCode;
+  } catch (err) {
+    console.error(`Could not reach ${cloudUrl}. Check your internet connection and cloud URL.`);
+    process.exit(1);
+  }
+  console.log("");
+  console.log(`  Code: ${deviceCode}`);
+  console.log("");
+  console.log("  Opening browser for authorization...");
+  console.log(`  If it doesn't open, visit: ${cloudUrl}/device?code=${deviceCode}`);
+  console.log("");
+  const verifyUrl = `${cloudUrl}/device?code=${deviceCode}`;
+  try {
+    const { exec } = await import("child_process");
+    const platform = process.platform;
+    if (platform === "win32") {
+      exec(`start "" "${verifyUrl}"`);
+    } else if (platform === "darwin") {
+      exec(`open "${verifyUrl}"`);
+    } else {
+      exec(`xdg-open "${verifyUrl}"`);
+    }
+  } catch {
+  }
+  console.log("  Waiting for authorization...");
+  const pollInterval = 2e3;
+  const maxWait = 15 * 60 * 1e3;
+  const startTime = Date.now();
+  while (Date.now() - startTime < maxWait) {
+    await new Promise((r) => setTimeout(r, pollInterval));
+    try {
+      const res = await fetch(`${cloudUrl}/api/auth/device/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ deviceCode })
+      });
+      if (!res.ok) continue;
+      const data = await res.json();
+      if (data.status === "authorized" && data.token) {
+        const configPath = options.config ?? getDefaultConfigPath();
+        writeConfigToken(data.token, configPath);
+        console.log("");
+        console.log(`  \u2713 Authenticated successfully!`);
+        console.log(`  Token saved to ${configPath}`);
+        console.log("");
+        console.log("  Run `cronies start` to begin.");
+        return;
+      }
+      if (data.status === "expired") {
+        console.error("\n  Device code expired. Please run `cronies login` again.");
+        process.exit(1);
+      }
+      process.stdout.write(".");
+    } catch {
+      process.stdout.write("x");
+    }
+  }
+  console.error("\n  Timed out waiting for authorization. Please run `cronies login` again.");
+  process.exit(1);
+});
+program.command("config").description("Show current configuration").option("-c, --config <path>", "Config file path").option("-e, --edit", "Open config in $EDITOR").action(async (options) => {
+  if (options.edit) {
+    const editor = process.env["EDITOR"] || process.env["VISUAL"];
+    if (!editor) {
+      console.error("No $EDITOR set. Set the EDITOR environment variable and try again.");
+      process.exit(1);
+    }
+    const { execSync } = await import("child_process");
+    const configPath = options.config ?? join(resolveDataDir(loadConfig(options.config)), "config.yaml");
+    try {
+      execSync(`${editor} "${configPath}"`, { stdio: "inherit" });
+    } catch {
+      console.error(`Failed to open editor: ${editor}`);
+      process.exit(1);
+    }
+    return;
+  }
+  const config = loadConfig(options.config);
+  console.log(toYaml(config));
+});
+program.command("jobs").description("List active jobs").action(async () => {
+  console.log("Connect daemon first with: cronies start");
+});
+program.command("runs").description("Show recent runs").argument("[runId]", "Specific run ID for details").action(async (runId) => {
+  if (runId) {
+    console.log(`Run details for ${runId} not yet implemented.`);
+  } else {
+    console.log("Recent runs not yet implemented. Start the daemon first: cronies start");
+  }
+});
+var EXAMPLE_JOB_YAML = `# Example Cronies job definition
+name: Example Maintenance Job
+prompt: |
+  Check for any TODO comments in the codebase and create a summary.
+  List files with TODOs and the TODO text.
+schedule:
+  type: manual
+preferredAgent: claude-code
+workingDirectory: .
+maxAttempts: 3
+timeout: 300000
+`;
+program.command("init").description("Initialize Cronies in current directory").action(async () => {
+  const croniesDir = join(process.cwd(), ".cronies");
+  const jobsDir = join(croniesDir, "jobs");
+  mkdirSync(jobsDir, { recursive: true });
+  const examplePath = join(jobsDir, "example.yaml");
+  writeFileSync(examplePath, EXAMPLE_JOB_YAML, "utf-8");
+  console.log("Initialized Cronies in current directory:");
+  console.log(`  .cronies/`);
+  console.log(`  .cronies/jobs/`);
+  console.log(`  .cronies/jobs/example.yaml`);
+  console.log("");
+  console.log("Edit .cronies/jobs/example.yaml to define your first job.");
+  console.log("Then start the daemon with: cronies start");
+});
+
+// bin/cronies.ts
+program.parse();

package/dist/index.js

@@ -0,0 +1,189 @@
+import {
+  DaemonConfigSchema,
+  DaemonStore,
+  JobRunner,
+  LocalPolicyEngine,
+  PROTOCOL_VERSION,
+  SessionHealthMonitor,
+  SyncQueue,
+  SyncReconciler,
+  createAdapterManager,
+  createDatabase,
+  createEnvelope,
+  createLogger,
+  decodeMessage,
+  encodeMessage,
+  isDaemonRunning,
+  loadConfig,
+  readPidFile,
+  removePidFile,
+  resolveDataDir,
+  startDaemon,
+  writePidFile
+} from "./chunk-FVB2S2MS.js";
+
+// src/sync/connection.ts
+import WebSocket from "ws";
+var SyncClient = class {
+  ws = null;
+  options;
+  reconnectAttempts = 0;
+  maxReconnectDelay = 3e4;
+  heartbeatInterval = null;
+  reconnectTimer = null;
+  connected = false;
+  intentionallyClosed = false;
+  constructor(options) {
+    this.options = options;
+  }
+  // -----------------------------------------------------------------------
+  // Public API
+  // -----------------------------------------------------------------------
+  connect() {
+    this.intentionallyClosed = false;
+    const ws = new WebSocket(this.options.wsUrl, {
+      headers: {
+        authorization: `Bearer ${this.options.daemonToken}`
+      }
+    });
+    ws.on("open", () => {
+      this.ws = ws;
+      this.connected = true;
+      this.reconnectAttempts = 0;
+      this.send({
+        ...createEnvelope("daemon:hello", {}),
+        type: "daemon:hello",
+        daemonId: this.options.daemonId,
+        lastCloudSeq: 0,
+        // TODO: read from store
+        protocolVersion: PROTOCOL_VERSION,
+        daemonVersion: this.options.daemonVersion,
+        hostname: this.options.hostname
+      });
+      this.startHeartbeat();
+      this.options.onConnected();
+    });
+    ws.on("message", (data) => {
+      try {
+        const raw = typeof data === "string" ? data : data.toString();
+        const message = decodeMessage(raw);
+        if (message.type.startsWith("cloud:")) {
+          this.options.onMessage(message);
+        }
+      } catch (err) {
+        console.error("[sync:connection] Failed to decode message:", err);
+      }
+    });
+    ws.on("close", (_code, _reason) => {
+      this.handleDisconnect();
+    });
+    ws.on("error", (err) => {
+      console.error("[sync:connection] WebSocket error:", err.message);
+    });
+  }
+  disconnect() {
+    this.intentionallyClosed = true;
+    this.stopHeartbeat();
+    this.clearReconnectTimer();
+    if (this.ws) {
+      try {
+        this.ws.close(1e3, "Client disconnect");
+      } catch {
+      }
+      this.ws = null;
+    }
+    this.connected = false;
+  }
+  /**
+   * Send a message to the cloud.
+   * Returns true if the message was sent, false if not connected.
+   * When false, the caller should enqueue the message in the outbox.
+   */
+  send(message) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return false;
+    }
+    try {
+      this.ws.send(encodeMessage(message));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  isConnected() {
+    return this.connected;
+  }
+  // -----------------------------------------------------------------------
+  // Private
+  // -----------------------------------------------------------------------
+  handleDisconnect() {
+    this.connected = false;
+    this.ws = null;
+    this.stopHeartbeat();
+    this.options.onDisconnected();
+    if (!this.intentionallyClosed) {
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    this.clearReconnectTimer();
+    const delay = Math.min(
+      1e3 * Math.pow(2, this.reconnectAttempts),
+      this.maxReconnectDelay
+    );
+    this.reconnectAttempts++;
+    console.log(
+      `[sync:connection] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`
+    );
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, delay);
+  }
+  clearReconnectTimer() {
+    if (this.reconnectTimer !== null) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatInterval = setInterval(() => {
+      this.send({
+        ...createEnvelope("daemon:heartbeat", {}),
+        type: "daemon:heartbeat",
+        daemonId: this.options.daemonId,
+        activeJobs: 0,
+        // TODO: get from orchestrator
+        cpuUsage: 0,
+        memoryUsage: 0
+      });
+    }, 3e4);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatInterval !== null) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+};
+export {
+  DaemonConfigSchema,
+  DaemonStore,
+  JobRunner,
+  LocalPolicyEngine,
+  SessionHealthMonitor,
+  SyncClient,
+  SyncQueue,
+  SyncReconciler,
+  createAdapterManager,
+  createDatabase,
+  createLogger,
+  isDaemonRunning,
+  loadConfig,
+  readPidFile,
+  removePidFile,
+  resolveDataDir,
+  startDaemon,
+  writePidFile
+};

package/dist/src/adapters/index.d.ts

@@ -0,0 +1,2 @@
+export { createAdapterManager } from './manager.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC"}

package/dist/src/adapters/manager.d.ts

@@ -0,0 +1,6 @@
+import { AdapterManager } from '@cronies/adapters';
+/**
+ * Create a pre-configured AdapterManager with all supported agent adapters.
+ */
+export declare function createAdapterManager(): AdapterManager;
+//# sourceMappingURL=manager.d.ts.map

package/dist/src/adapters/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../src/adapters/manager.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EAKf,MAAM,mBAAmB,CAAC;AAE3B;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,cAAc,CAOrD"}

package/dist/src/cli/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const program: Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cli/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAkIpC,eAAO,MAAM,OAAO,SAGD,CAAC"}

package/dist/src/config/index.d.ts

@@ -0,0 +1,4 @@
+export { DaemonConfigSchema, type DaemonConfig } from './schema.js';
+export { loadConfig, resolveDataDir } from './loader.js';
+export { writeConfigToken, getDefaultConfigPath } from './writer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC"}

package/dist/src/config/loader.d.ts

@@ -0,0 +1,13 @@
+import { type DaemonConfig } from './schema.js';
+/**
+ * Load and validate daemon configuration.
+ *
+ * @param configPath - Path to YAML config file. Defaults to `~/.cronies/config.yaml`.
+ * @returns Validated daemon configuration with defaults applied.
+ */
+export declare function loadConfig(configPath?: string): DaemonConfig;
+/**
+ * Resolve the data directory from a daemon config, expanding `~` to the home directory.
+ */
+export declare function resolveDataDir(config: DaemonConfig): string;
+//# sourceMappingURL=loader.d.ts.map

package/dist/src/config/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../src/config/loader.ts"],"names":[],"mappings":"AAIA,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAapE;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,YAAY,CAoB5D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAE3D"}