@mrsekut/ccron 0.1.0

package/src/commands/test.ts

@@ -0,0 +1,223 @@
+import {
+  readTaskConfig,
+  readGlobalConfig,
+  scriptPath,
+  plistPath,
+  mcpConfigPath,
+} from '../config';
+import { listOne } from '../launchd';
+import { homedir } from 'os';
+
+type CheckResult = {
+  label: string;
+  ok: boolean;
+  detail: string;
+  fix?: string | undefined;
+};
+
+export async function testCommand(args: string[]): Promise<void> {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`ccron test - Run environment checks for a task
+
+Usage: ccron test <name>
+
+Checks:
+  1. claude CLI found in PATH
+  2. claude auth status (logged in)
+  3. ulimit -n (file descriptors)
+  4. Script file exists
+  5. Script path is outside TCC-protected directories
+  6. Plist registered in launchd
+  7. MCP config exists (if task uses MCP)
+
+Each failed check shows a suggested fix command.
+
+Example:
+  ccron test daily-summary`);
+    return;
+  }
+
+  const name = args[0];
+  if (!name) {
+    console.error('Usage: ccron test <name>');
+    process.exit(1);
+  }
+
+  const task = await readTaskConfig(name);
+  if (!task) {
+    console.error(`Task "${name}" not found.`);
+    process.exit(1);
+  }
+
+  console.log(`Checking ${name}...\n`);
+
+  const checks: CheckResult[] = [];
+
+  checks.push(await checkClaudeCli());
+  checks.push(await checkClaudeAuth());
+  checks.push(await checkUlimit());
+  checks.push(await checkScriptExists(name));
+  checks.push(checkScriptTccSafe(name));
+  checks.push(await checkPlistRegistered(name));
+
+  if (task.mcp.length > 0) {
+    checks.push(await checkMcpConfig(name));
+  }
+
+  // Print results
+  for (const check of checks) {
+    if (check.ok) {
+      console.log(`  ✓ ${check.label}: ${check.detail}`);
+    } else {
+      console.log(`  ✗ ${check.label}: ${check.detail}`);
+      if (check.fix) {
+        console.log(`    → ${check.fix}`);
+      }
+    }
+  }
+
+  const passed = checks.filter(c => c.ok).length;
+  const failed = checks.filter(c => !c.ok).length;
+  console.log(`\n${passed}/${checks.length} checks passed.`);
+  if (failed > 0) {
+    console.log(`${failed} issue(s) found.`);
+    process.exit(1);
+  }
+}
+
+async function checkClaudeCli(): Promise<CheckResult> {
+  try {
+    const result = await Bun.$`which claude`.quiet();
+    if (result.exitCode === 0) {
+      const path = result.stdout.toString().trim();
+      // Try to get version
+      const ver = await Bun.$`claude --version`.quiet();
+      const version = ver.exitCode === 0 ? ver.stdout.toString().trim() : '';
+      return {
+        label: 'claude CLI',
+        ok: true,
+        detail: `found (${path}${version ? ` ${version}` : ''})`,
+      };
+    }
+  } catch {
+    // fall through
+  }
+  return {
+    label: 'claude CLI',
+    ok: false,
+    detail: 'not found in PATH',
+    fix: 'Install claude CLI or set path with ccron config',
+  };
+}
+
+async function checkClaudeAuth(): Promise<CheckResult> {
+  try {
+    const result = await Bun.$`claude auth status`.quiet();
+    const output = result.stdout.toString() + result.stderr.toString();
+    if (result.exitCode === 0) {
+      return {
+        label: 'claude auth',
+        ok: true,
+        detail: 'authenticated',
+      };
+    }
+    return {
+      label: 'claude auth',
+      ok: false,
+      detail: output.trim() || 'not authenticated',
+      fix: 'Run: claude auth login',
+    };
+  } catch {
+    return {
+      label: 'claude auth',
+      ok: false,
+      detail: 'failed to check',
+      fix: 'Run: claude auth login',
+    };
+  }
+}
+
+async function checkUlimit(): Promise<CheckResult> {
+  const global = await readGlobalConfig();
+  try {
+    const result = await Bun.$`ulimit -n`.quiet();
+    const current = Number(result.stdout.toString().trim());
+    if (current >= global.ulimit) {
+      return {
+        label: 'ulimit -n',
+        ok: true,
+        detail: `${current} (sufficient)`,
+      };
+    }
+    return {
+      label: 'ulimit -n',
+      ok: true, // Script sets it, so just a warning
+      detail: `${current} (script will set to ${global.ulimit})`,
+    };
+  } catch {
+    return {
+      label: 'ulimit -n',
+      ok: true,
+      detail: 'could not check (script will set it)',
+    };
+  }
+}
+
+async function checkScriptExists(name: string): Promise<CheckResult> {
+  const path = scriptPath(name);
+  const exists = await Bun.file(path).exists();
+  return {
+    label: 'script',
+    ok: exists,
+    detail: exists ? `exists (${path})` : `not found (${path})`,
+    fix: exists ? undefined : `Re-register: ccron add --name ${name} ...`,
+  };
+}
+
+function checkScriptTccSafe(name: string): CheckResult {
+  const path = scriptPath(name);
+  const home = homedir();
+  const tccDirs = [`${home}/Desktop`, `${home}/Documents`, `${home}/Downloads`];
+  const inTcc = tccDirs.some(dir => path.startsWith(dir));
+  return {
+    label: 'TCC protection',
+    ok: !inTcc,
+    detail: inTcc
+      ? `script is in TCC-protected directory`
+      : `script path is outside TCC-protected directories`,
+    fix: inTcc
+      ? 'Move script outside ~/Desktop, ~/Documents, ~/Downloads'
+      : undefined,
+  };
+}
+
+async function checkPlistRegistered(name: string): Promise<CheckResult> {
+  const status = await listOne(name);
+  const path = plistPath(name);
+  const fileExists = await Bun.file(path).exists();
+
+  if (status) {
+    return {
+      label: 'launchd',
+      ok: true,
+      detail: `registered (pid: ${status.pid ?? 'idle'})`,
+    };
+  }
+  return {
+    label: 'launchd',
+    ok: false,
+    detail: fileExists ? 'plist exists but not loaded' : 'plist not found',
+    fix: `Re-register: ccron add --name ${name} ...`,
+  };
+}
+
+async function checkMcpConfig(name: string): Promise<CheckResult> {
+  const path = mcpConfigPath(name);
+  const exists = await Bun.file(path).exists();
+  return {
+    label: 'MCP config',
+    ok: exists,
+    detail: exists ? `exists (${path})` : `not found (${path})`,
+    fix: exists ? undefined : `Re-register with --mcp flag`,
+  };
+}

package/src/config.ts

@@ -0,0 +1,141 @@
+import { homedir } from 'os';
+import { join } from 'path';
+
+// --- Types ---
+
+export type TaskConfig = {
+  name: string;
+  schedule: string;
+  prompt: string | null;
+  promptFile: string | null;
+  mcp: string[];
+  allowedTools: string[];
+  maxTurns: number | null;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type GlobalConfig = {
+  claudePath: string;
+  extraPaths: string[];
+  ulimit: number;
+};
+
+// --- Paths ---
+
+const home = homedir();
+
+export const PATHS = {
+  configDir: join(home, '.config', 'ccron'),
+  tasksDir: join(home, '.config', 'ccron', 'tasks'),
+  mcpDir: join(home, '.config', 'ccron', 'mcp'),
+  globalConfig: join(home, '.config', 'ccron', 'config.json'),
+  binDir: join(home, '.local', 'bin'),
+  logsDir: join(home, '.local', 'share', 'ccron', 'logs'),
+  launchAgentsDir: join(home, 'Library', 'LaunchAgents'),
+} as const;
+
+export function taskConfigPath(name: string): string {
+  return join(PATHS.tasksDir, `${name}.json`);
+}
+
+export function mcpConfigPath(name: string): string {
+  return join(PATHS.mcpDir, `${name}.json`);
+}
+
+export function scriptPath(name: string): string {
+  return join(PATHS.binDir, `ccron-${name}.sh`);
+}
+
+export function plistPath(name: string): string {
+  return join(PATHS.launchAgentsDir, `com.ccron.${name}.plist`);
+}
+
+export function logPath(name: string): string {
+  return join(PATHS.logsDir, `${name}.log`);
+}
+
+export function plistLabel(name: string): string {
+  return `com.ccron.${name}`;
+}
+
+// --- I/O ---
+
+export async function ensureDirectories(): Promise<void> {
+  const { mkdir } = await import('fs/promises');
+  await Promise.all([
+    mkdir(PATHS.tasksDir, { recursive: true }),
+    mkdir(PATHS.mcpDir, { recursive: true }),
+    mkdir(PATHS.binDir, { recursive: true }),
+    mkdir(PATHS.logsDir, { recursive: true }),
+    mkdir(PATHS.launchAgentsDir, { recursive: true }),
+  ]);
+}
+
+export async function readTaskConfig(name: string): Promise<TaskConfig | null> {
+  const file = Bun.file(taskConfigPath(name));
+  if (!(await file.exists())) return null;
+  return file.json() as Promise<TaskConfig>;
+}
+
+export async function writeTaskConfig(config: TaskConfig): Promise<void> {
+  await Bun.write(taskConfigPath(config.name), JSON.stringify(config, null, 2));
+}
+
+export async function listTaskConfigs(): Promise<TaskConfig[]> {
+  const { readdir } = await import('fs/promises');
+  let files: string[];
+  try {
+    files = await readdir(PATHS.tasksDir);
+  } catch {
+    return [];
+  }
+  const tasks: TaskConfig[] = [];
+  for (const file of files) {
+    if (!file.endsWith('.json')) continue;
+    const content = await Bun.file(join(PATHS.tasksDir, file)).json();
+    tasks.push(content as TaskConfig);
+  }
+  return tasks;
+}
+
+export async function deleteTaskConfig(name: string): Promise<void> {
+  const { unlink } = await import('fs/promises');
+  try {
+    await unlink(taskConfigPath(name));
+  } catch {
+    // ignore if not found
+  }
+}
+
+export async function readGlobalConfig(): Promise<GlobalConfig> {
+  const file = Bun.file(PATHS.globalConfig);
+  if (!(await file.exists())) {
+    return defaultGlobalConfig();
+  }
+  return file.json() as Promise<GlobalConfig>;
+}
+
+export async function writeGlobalConfig(config: GlobalConfig): Promise<void> {
+  await Bun.write(PATHS.globalConfig, JSON.stringify(config, null, 2));
+}
+
+function defaultGlobalConfig(): GlobalConfig {
+  return {
+    claudePath: '',
+    extraPaths: [],
+    ulimit: 2147483646,
+  };
+}
+
+// --- Validation (pure) ---
+
+const TASK_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
+
+export function validateTaskName(name: string): string | null {
+  if (!name) return 'Task name is required';
+  if (!TASK_NAME_RE.test(name))
+    return 'Task name must contain only lowercase letters, numbers, and hyphens, and start with a letter or number';
+  if (name.length > 64) return 'Task name must be 64 characters or less';
+  return null;
+}

package/src/generator.ts

@@ -0,0 +1,170 @@
+import type { TaskConfig, GlobalConfig } from './config';
+import type { CalendarInterval } from './schedule';
+import { logPath, mcpConfigPath, plistLabel, scriptPath } from './config';
+import { buildMcpConfig } from './mcp';
+import { homedir } from 'os';
+
+/**
+ * Generate the shell script content that launchd will execute.
+ */
+export function generateScriptContent(
+  task: TaskConfig,
+  global: GlobalConfig,
+): string {
+  const home = homedir();
+  const pathEntries = [
+    global.claudePath,
+    ...global.extraPaths,
+    '/usr/local/bin',
+    '/usr/bin',
+    '/bin',
+  ]
+    .filter(Boolean)
+    .join(':');
+
+  const lines: string[] = [
+    '#!/usr/bin/env bash',
+    '# Generated by ccron. Do not edit manually.',
+    'set -uo pipefail',
+    '',
+    `export HOME="${home}"`,
+    `export PATH="${pathEntries}:$PATH"`,
+    '',
+    `ulimit -n ${global.ulimit} 2>/dev/null || true`,
+    '',
+    'cd /tmp',
+    '',
+  ];
+
+  // Prompt handling
+  if (task.promptFile) {
+    lines.push(`PROMPT=$(cat "${task.promptFile}")`);
+  } else if (task.prompt) {
+    // Escape single quotes for bash
+    const escaped = task.prompt.replace(/'/g, "'\\''");
+    lines.push(`PROMPT='${escaped}'`);
+  }
+
+  lines.push('');
+
+  // Build claude command
+  const claudeArgs: string[] = ['claude -p "$PROMPT"'];
+
+  if (task.mcp.length > 0) {
+    claudeArgs.push(`  --mcp-config "${mcpConfigPath(task.name)}"`);
+  }
+
+  if (task.allowedTools.length > 0) {
+    claudeArgs.push(`  --allowedTools "${task.allowedTools.join(',')}"`);
+  }
+
+  if (task.maxTurns !== null) {
+    claudeArgs.push(`  --max-turns ${task.maxTurns}`);
+  }
+
+  lines.push(claudeArgs.join(' \\\n'));
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate the launchd plist XML content.
+ */
+export function generatePlistContent(
+  task: TaskConfig,
+  global: GlobalConfig,
+  intervals: CalendarInterval[],
+): string {
+  const home = homedir();
+  const pathEntries = [
+    global.claudePath,
+    ...global.extraPaths,
+    '/usr/local/bin',
+    '/usr/bin',
+    '/bin',
+  ]
+    .filter(Boolean)
+    .join(':');
+
+  const label = plistLabel(task.name);
+  const script = scriptPath(task.name);
+  const log = logPath(task.name);
+
+  const calendarIntervalXml = generateCalendarIntervalXml(intervals);
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${escapeXml(label)}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>/bin/bash</string>
+        <string>${escapeXml(script)}</string>
+    </array>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>HOME</key>
+        <string>${escapeXml(home)}</string>
+        <key>PATH</key>
+        <string>${escapeXml(pathEntries)}</string>
+    </dict>
+    <key>WorkingDirectory</key>
+    <string>/tmp</string>
+    <key>StartCalendarInterval</key>
+${calendarIntervalXml}
+    <key>StandardOutPath</key>
+    <string>${escapeXml(log)}</string>
+    <key>StandardErrorPath</key>
+    <string>${escapeXml(log)}</string>
+</dict>
+</plist>
+`;
+}
+
+function generateCalendarIntervalXml(intervals: CalendarInterval[]): string {
+  if (intervals.length === 1) {
+    return indent(calendarIntervalDict(intervals[0]!), 4);
+  }
+
+  const items = intervals.map(i => indent(calendarIntervalDict(i), 8));
+  return `    <array>\n${items.join('\n')}\n    </array>`;
+}
+
+function calendarIntervalDict(interval: CalendarInterval): string {
+  const entries: string[] = [];
+  entries.push(`<key>Hour</key>\n<integer>${interval.Hour}</integer>`);
+  entries.push(`<key>Minute</key>\n<integer>${interval.Minute}</integer>`);
+  if (interval.Weekday !== undefined) {
+    entries.push(`<key>Weekday</key>\n<integer>${interval.Weekday}</integer>`);
+  }
+  return `<dict>\n${entries.map(e => indent(e, 4)).join('\n')}\n</dict>`;
+}
+
+function indent(text: string, spaces: number): string {
+  const pad = ' '.repeat(spaces);
+  return text
+    .split('\n')
+    .map(line => pad + line)
+    .join('\n');
+}
+
+function escapeXml(str: string): string {
+  return str
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+/**
+ * Generate MCP config JSON string from task's MCP presets.
+ */
+export function generateMcpConfigContent(presets: string[]): string {
+  const config = buildMcpConfig(presets);
+  return JSON.stringify(config, null, 2);
+}

package/src/launchd.ts

@@ -0,0 +1,61 @@
+import { plistLabel } from './config';
+
+export async function bootstrap(plistPath: string): Promise<void> {
+  const uid = process.getuid?.() ?? 501;
+  const result =
+    await Bun.$`launchctl bootstrap gui/${uid} ${plistPath}`.quiet();
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.toString().trim();
+    // Already bootstrapped is not an error
+    if (stderr.includes('service already bootstrapped')) return;
+    throw new Error(`launchctl bootstrap failed: ${stderr}`);
+  }
+}
+
+export async function bootout(name: string): Promise<void> {
+  const uid = process.getuid?.() ?? 501;
+  const label = plistLabel(name);
+  const result = await Bun.$`launchctl bootout gui/${uid}/${label}`.quiet();
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.toString().trim();
+    // Not found is not an error during removal
+    if (stderr.includes('Could not find service')) return;
+    throw new Error(`launchctl bootout failed: ${stderr}`);
+  }
+}
+
+export async function kickstart(name: string): Promise<void> {
+  const uid = process.getuid?.() ?? 501;
+  const label = plistLabel(name);
+  const result = await Bun.$`launchctl kickstart gui/${uid}/${label}`.quiet();
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `launchctl kickstart failed: ${result.stderr.toString().trim()}`,
+    );
+  }
+}
+
+export type LaunchdStatus = {
+  pid: number | null;
+  lastExitStatus: number | null;
+};
+
+export async function listOne(name: string): Promise<LaunchdStatus | null> {
+  const label = plistLabel(name);
+  const result = await Bun.$`launchctl list ${label}`.quiet();
+  if (result.exitCode !== 0) return null;
+
+  const output = result.stdout.toString();
+  let pid: number | null = null;
+  let lastExitStatus: number | null = null;
+
+  for (const line of output.split('\n')) {
+    const trimmed = line.trim();
+    const pidMatch = trimmed.match(/^"PID"\s*=\s*(\d+)/);
+    if (pidMatch) pid = Number(pidMatch[1]);
+    const statusMatch = trimmed.match(/^"LastExitStatus"\s*=\s*(\d+)/);
+    if (statusMatch) lastExitStatus = Number(statusMatch[1]);
+  }
+
+  return { pid, lastExitStatus };
+}

package/src/mcp.ts

@@ -0,0 +1,49 @@
+export type McpServerEntry = {
+  type: string;
+  url: string;
+};
+
+const MCP_PRESETS: Record<string, McpServerEntry> = {
+  slack: {
+    type: 'http',
+    url: 'https://mcp.slack.com/mcp',
+  },
+  linear: {
+    type: 'http',
+    url: 'https://mcp.linear.app/mcp',
+  },
+};
+
+export function getPresetNames(): string[] {
+  return Object.keys(MCP_PRESETS);
+}
+
+export function isKnownPreset(name: string): boolean {
+  return name in MCP_PRESETS;
+}
+
+export function validateMcpPresets(names: string[]): string | null {
+  const unknown = names.filter(n => !isKnownPreset(n));
+  if (unknown.length > 0) {
+    return `Unknown MCP preset(s): ${unknown.join(', ')}. Available: ${getPresetNames().join(', ')}`;
+  }
+  return null;
+}
+
+/**
+ * Build an MCP config JSON object from preset names.
+ * Output format matches claude CLI's --mcp-config expectation.
+ */
+export function buildMcpConfig(presets: string[]): {
+  mcpServers: Record<string, McpServerEntry>;
+} {
+  const servers: Record<string, McpServerEntry> = {};
+  for (const name of presets) {
+    const preset = MCP_PRESETS[name];
+    if (!preset) {
+      throw new Error(`Unknown MCP preset: ${name}`);
+    }
+    servers[name] = preset;
+  }
+  return { mcpServers: servers };
+}