@mrsekut/ccron 0.1.0

package/src/commands/edit.ts

@@ -0,0 +1,158 @@
+import {
+  readTaskConfig,
+  writeTaskConfig,
+  readGlobalConfig,
+  mcpConfigPath,
+  scriptPath,
+  plistPath,
+} from '../config';
+import { parseSchedule } from '../schedule';
+import { validateMcpPresets } from '../mcp';
+import {
+  generateScriptContent,
+  generatePlistContent,
+  generateMcpConfigContent,
+} from '../generator';
+import { bootout, bootstrap } from '../launchd';
+
+export async function editCommand(args: string[]): Promise<void> {
+  const { parseArgs } = require('util');
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      schedule: { type: 'string' },
+      prompt: { type: 'string' },
+      'prompt-file': { type: 'string' },
+      mcp: { type: 'string' },
+      'allowed-tools': { type: 'string' },
+      'max-turns': { type: 'string' },
+      help: { type: 'boolean', short: 'h' },
+    },
+    allowPositionals: true,
+    strict: true,
+  });
+
+  if (values.help) {
+    printEditHelp();
+    process.exit(0);
+  }
+
+  const name = positionals[0] as string | undefined;
+  if (!name) {
+    console.error('Usage: ccron edit <name> [options]');
+    process.exit(1);
+  }
+
+  const task = await readTaskConfig(name);
+  if (!task) {
+    console.error(`Task "${name}" not found.`);
+    process.exit(1);
+  }
+
+  let changed = false;
+
+  if (values.schedule !== undefined) {
+    task.schedule = values.schedule;
+    parseSchedule(task.schedule);
+    changed = true;
+  }
+
+  if (values.prompt !== undefined) {
+    task.prompt = values.prompt;
+    task.promptFile = null;
+    changed = true;
+  }
+
+  if (values['prompt-file'] !== undefined) {
+    task.promptFile = values['prompt-file'];
+    task.prompt = null;
+    if (!(await Bun.file(task.promptFile!).exists())) {
+      console.error(`Prompt file not found: ${task.promptFile}`);
+      process.exit(1);
+    }
+    changed = true;
+  }
+
+  if (values.mcp !== undefined) {
+    const mcpNames = values.mcp.split(',').filter(Boolean);
+    const mcpError = validateMcpPresets(mcpNames);
+    if (mcpError) {
+      console.error(`Error: ${mcpError}`);
+      process.exit(1);
+    }
+    task.mcp = mcpNames;
+    changed = true;
+  }
+
+  if (values['allowed-tools'] !== undefined) {
+    task.allowedTools = values['allowed-tools'].split(',').filter(Boolean);
+    changed = true;
+  }
+
+  if (values['max-turns'] !== undefined) {
+    task.maxTurns = Number(values['max-turns']);
+    changed = true;
+  }
+
+  if (!changed) {
+    console.log('No changes specified. Use --help to see available options.');
+    return;
+  }
+
+  task.updatedAt = new Date().toISOString();
+
+  const globalConfig = await readGlobalConfig();
+  const intervals = parseSchedule(task.schedule);
+
+  // Update task config
+  await writeTaskConfig(task);
+  console.log(`✓ Task config updated`);
+
+  // Regenerate MCP config
+  if (task.mcp.length > 0) {
+    await Bun.write(
+      mcpConfigPath(task.name),
+      generateMcpConfigContent(task.mcp),
+    );
+    console.log(`✓ MCP config regenerated`);
+  }
+
+  // Regenerate script
+  const scriptContent = generateScriptContent(task, globalConfig);
+  const scriptFile = scriptPath(task.name);
+  await Bun.write(scriptFile, scriptContent);
+  const { chmod } = await import('fs/promises');
+  await chmod(scriptFile, 0o755);
+  console.log(`✓ Script regenerated`);
+
+  // Regenerate plist
+  const plistContent = generatePlistContent(task, globalConfig, intervals);
+  await Bun.write(plistPath(task.name), plistContent);
+  console.log(`✓ Plist regenerated`);
+
+  // Reload launchd
+  await bootout(task.name);
+  await bootstrap(plistPath(task.name));
+  console.log(`✓ launchd reloaded`);
+
+  console.log(`\n"${task.name}" updated.`);
+}
+
+function printEditHelp() {
+  console.log(`ccron edit - Edit a task's configuration
+
+Usage: ccron edit <name> [options]
+
+Options:
+  --schedule <cron>       Update cron expression
+  --prompt <text>         Update prompt (clears --prompt-file)
+  --prompt-file <path>    Update prompt file (clears --prompt)
+  --mcp <names>           Update MCP presets (comma-separated)
+  --allowed-tools <tools> Update allowed tools (comma-separated)
+  --max-turns <n>         Update max turns
+
+Examples:
+  ccron edit daily-summary --schedule "0 18 * * 1-5"
+  ccron edit daily-summary --prompt-file ./prompts/v2.txt
+  ccron edit daily-summary --mcp slack,linear`);
+}

package/src/commands/list.ts

@@ -0,0 +1,58 @@
+import { listTaskConfigs } from '../config';
+import { listOne } from '../launchd';
+
+export async function listCommand(args: string[]): Promise<void> {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`ccron list - List all registered tasks
+
+Usage: ccron list
+
+Shows all tasks with their schedule, launchd status, and last exit code.
+
+Columns:
+  NAME       Task name
+  SCHEDULE   Cron expression
+  STATUS     "active" (loaded in launchd) or "not loaded"
+  LAST EXIT  Exit code of last execution (0 = success)`);
+    return;
+  }
+
+  const tasks = await listTaskConfigs();
+
+  if (tasks.length === 0) {
+    console.log('No tasks registered. Use `ccron add` to create one.');
+    return;
+  }
+
+  // Header
+  const nameW = Math.max(4, ...tasks.map(t => t.name.length));
+  const schedW = Math.max(8, ...tasks.map(t => t.schedule.length));
+
+  const header = [
+    'NAME'.padEnd(nameW),
+    'SCHEDULE'.padEnd(schedW),
+    'STATUS'.padEnd(10),
+    'LAST EXIT',
+  ].join('  ');
+
+  console.log(header);
+  console.log('-'.repeat(header.length));
+
+  for (const task of tasks) {
+    const status = await listOne(task.name);
+    const statusStr = status ? 'active' : 'not loaded';
+    const exitStr =
+      status?.lastExitStatus !== null && status?.lastExitStatus !== undefined
+        ? String(status.lastExitStatus)
+        : '-';
+
+    console.log(
+      [
+        task.name.padEnd(nameW),
+        task.schedule.padEnd(schedW),
+        statusStr.padEnd(10),
+        exitStr,
+      ].join('  '),
+    );
+  }
+}

package/src/commands/log.ts

@@ -0,0 +1,61 @@
+import { readTaskConfig, logPath } from '../config';
+import { spawn } from 'child_process';
+
+export async function logCommand(args: string[]): Promise<void> {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`ccron log - Show task execution logs
+
+Usage: ccron log <name> [--follow]
+
+Options:
+  --follow, -f   Tail the log in real-time (Ctrl+C to stop)
+
+Without --follow, shows the last 50 lines of the log.
+
+Log location: ~/.local/share/ccron/logs/<name>.log
+
+Examples:
+  ccron log daily-summary
+  ccron log daily-summary --follow`);
+    return;
+  }
+
+  const name = args.find(a => !a.startsWith('-'));
+  const follow = args.includes('--follow') || args.includes('-f');
+
+  if (!name) {
+    console.error('Usage: ccron log <name> [--follow]');
+    process.exit(1);
+  }
+
+  const task = await readTaskConfig(name);
+  if (!task) {
+    console.error(`Task "${name}" not found.`);
+    process.exit(1);
+  }
+
+  const log = logPath(name);
+  const file = Bun.file(log);
+
+  if (!(await file.exists())) {
+    console.log(`No logs yet for "${name}".`);
+    return;
+  }
+
+  if (follow) {
+    const tail = spawn('tail', ['-f', log], {
+      stdio: ['ignore', 'inherit', 'inherit'],
+    });
+    process.on('SIGINT', () => {
+      tail.kill();
+      process.exit(0);
+    });
+    await new Promise<void>(resolve => {
+      tail.on('close', () => resolve());
+    });
+  } else {
+    // Show last 50 lines
+    const result = await Bun.$`tail -50 ${log}`.quiet();
+    console.log(result.stdout.toString());
+  }
+}

package/src/commands/remove.ts

@@ -0,0 +1,94 @@
+import {
+  readTaskConfig,
+  deleteTaskConfig,
+  scriptPath,
+  plistPath,
+  mcpConfigPath,
+  logPath,
+  listTaskConfigs,
+} from '../config';
+import { bootout } from '../launchd';
+
+export async function removeCommand(args: string[]): Promise<void> {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`ccron remove - Remove a registered task
+
+Usage: ccron remove <name> [--purge]
+
+Removes a task by:
+  1. Unregistering from launchd (launchctl bootout)
+  2. Deleting plist, script, task config
+  3. Deleting MCP config (if not used by other tasks)
+
+Options:
+  --purge   Also delete log files (logs are kept by default)
+
+Examples:
+  ccron remove daily-summary
+  ccron remove daily-summary --purge`);
+    return;
+  }
+
+  const purge = args.includes('--purge');
+  const name = args.find(a => !a.startsWith('-'));
+
+  if (!name) {
+    console.error('Usage: ccron remove <name> [--purge]');
+    process.exit(1);
+  }
+
+  const task = await readTaskConfig(name);
+  if (!task) {
+    console.error(`Task "${name}" not found.`);
+    process.exit(1);
+  }
+
+  // 1. Unregister from launchd
+  await bootout(name);
+  console.log(`✓ Unregistered from launchd`);
+
+  // 2. Delete plist
+  await tryUnlink(plistPath(name));
+  console.log(`✓ Plist removed`);
+
+  // 3. Delete script
+  await tryUnlink(scriptPath(name));
+  console.log(`✓ Script removed`);
+
+  // 4. Delete MCP config if not shared by other tasks
+  if (task.mcp.length > 0) {
+    const otherTasks = await listTaskConfigs();
+    const otherUsing = otherTasks.some(
+      t => t.name !== name && t.mcp.some(m => task.mcp.includes(m)),
+    );
+    if (!otherUsing) {
+      await tryUnlink(mcpConfigPath(name));
+      console.log(`✓ MCP config removed`);
+    } else {
+      console.log(`  MCP config kept (used by other tasks)`);
+    }
+  }
+
+  // 5. Delete task config
+  await deleteTaskConfig(name);
+  console.log(`✓ Task config removed`);
+
+  // 6. Logs
+  if (purge) {
+    await tryUnlink(logPath(name));
+    console.log(`✓ Logs purged`);
+  } else {
+    console.log(`  Logs kept at ${logPath(name)} (use --purge to remove)`);
+  }
+
+  console.log(`\n"${name}" removed.`);
+}
+
+async function tryUnlink(path: string): Promise<void> {
+  const { unlink } = await import('fs/promises');
+  try {
+    await unlink(path);
+  } catch {
+    // ignore
+  }
+}

package/src/commands/run.ts

@@ -0,0 +1,61 @@
+import { readTaskConfig, logPath } from '../config';
+import { kickstart } from '../launchd';
+import { spawn } from 'child_process';
+
+export async function runCommand(args: string[]): Promise<void> {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`ccron run - Manually trigger a task
+
+Usage: ccron run <name>
+
+Kicks start the task via launchctl and tails the log file in real-time.
+Press Ctrl+C to stop following the log (the task continues running).
+
+Example:
+  ccron run daily-summary`);
+    return;
+  }
+
+  const name = args[0];
+  if (!name) {
+    console.error('Usage: ccron run <name>');
+    process.exit(1);
+  }
+
+  const task = await readTaskConfig(name);
+  if (!task) {
+    console.error(`Task "${name}" not found.`);
+    process.exit(1);
+  }
+
+  const log = logPath(name);
+
+  // Ensure log file exists for tail
+  await Bun.write(
+    log,
+    await Bun.file(log)
+      .text()
+      .catch(() => ''),
+    {
+      createPath: true,
+    },
+  );
+
+  console.log(`Kicking start ${name}...`);
+  await kickstart(name);
+  console.log(`Started. Tailing log (Ctrl+C to stop):\n`);
+
+  // tail -f the log file
+  const tail = spawn('tail', ['-f', log], {
+    stdio: ['ignore', 'inherit', 'inherit'],
+  });
+
+  process.on('SIGINT', () => {
+    tail.kill();
+    process.exit(0);
+  });
+
+  await new Promise<void>(resolve => {
+    tail.on('close', () => resolve());
+  });
+}

package/src/commands/show.ts

@@ -0,0 +1,91 @@
+import {
+  readTaskConfig,
+  scriptPath,
+  plistPath,
+  logPath,
+  taskConfigPath,
+  mcpConfigPath,
+} from '../config';
+import { listOne } from '../launchd';
+
+export async function showCommand(args: string[]): Promise<void> {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`ccron show - Show detailed information about a task
+
+Usage: ccron show <name>
+
+Displays task configuration, launchd status, and file locations.`);
+    return;
+  }
+
+  const name = args[0];
+  if (!name) {
+    console.error('Task name is required. Usage: ccron show <name>');
+    process.exit(1);
+  }
+
+  const task = await readTaskConfig(name);
+  if (!task) {
+    console.error(`Task "${name}" not found.`);
+    process.exit(1);
+  }
+
+  const status = await listOne(name);
+  const statusStr = status
+    ? status.pid
+      ? `active (pid: ${status.pid})`
+      : 'active (pid: idle)'
+    : 'not loaded';
+  const exitStr =
+    status?.lastExitStatus !== null && status?.lastExitStatus !== undefined
+      ? String(status.lastExitStatus)
+      : '-';
+
+  const promptDisplay = task.promptFile
+    ? `(file) ${task.promptFile}`
+    : task.prompt && task.prompt.length > 80
+      ? task.prompt.slice(0, 80) + '...'
+      : (task.prompt ?? '(none)');
+
+  const lines = [
+    `Name:       ${task.name}`,
+    `Schedule:   ${task.schedule}`,
+    `Prompt:     ${promptDisplay}`,
+    `MCP:        ${task.mcp.length > 0 ? task.mcp.join(', ') : '(none)'}`,
+    `Tools:      ${task.allowedTools.length > 0 ? task.allowedTools.join(', ') : '(none)'}`,
+    `Max turns:  ${task.maxTurns ?? '(default)'}`,
+    `Status:     ${statusStr}`,
+    `Last exit:  ${exitStr}`,
+    `Created:    ${formatDate(task.createdAt)}`,
+    `Updated:    ${formatDate(task.updatedAt)}`,
+    ``,
+    `Files:`,
+    `  Config:   ${shorten(taskConfigPath(name))}`,
+    `  Script:   ${shorten(scriptPath(name))}`,
+    `  Plist:    ${shorten(plistPath(name))}`,
+    `  Log:      ${shorten(logPath(name))}`,
+  ];
+
+  if (task.mcp.length > 0) {
+    lines.push(`  MCP:      ${shorten(mcpConfigPath(name))}`);
+  }
+
+  console.log(lines.join('\n'));
+}
+
+function formatDate(iso: string): string {
+  const d = new Date(iso);
+  return d.toLocaleString('ja-JP', {
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+  });
+}
+
+function shorten(path: string): string {
+  const home = process.env['HOME'] ?? '';
+  return home && path.startsWith(home) ? '~' + path.slice(home.length) : path;
+}