codewake 0.0.1

package/lib/time.js

@@ -0,0 +1,88 @@
+const UNIT_SECONDS = { d: 86400, h: 3600, m: 60, s: 1 };
+
+// Full unit words only: matching just the first letter would silently turn
+// "1 month" into one minute — unacceptable for a scheduler.
+const UNIT_WORDS = new Map(Object.entries({
+  d: 'd', day: 'd', days: 'd',
+  h: 'h', hr: 'h', hrs: 'h', hour: 'h', hours: 'h',
+  m: 'm', min: 'm', mins: 'm', minute: 'm', minutes: 'm',
+  s: 's', sec: 's', secs: 's', second: 's', seconds: 's',
+}));
+
+/**
+ * Parse a human duration ("2h 30m", "45m", "1d", "90") into seconds.
+ * A bare number is interpreted as minutes. Unknown units are an error.
+ */
+export function parseDuration(text) {
+  const raw = String(text ?? '').trim().toLowerCase();
+  if (!raw) throw new Error('Duration is empty. Try something like "2h 30m".');
+  if (/^\d+$/.test(raw)) return Number(raw) * 60;
+  let total = 0;
+  let unknownUnit = null;
+  const leftovers = raw.replace(/(\d+)\s*([a-z]+)/g, (match, amount, word) => {
+    const unit = UNIT_WORDS.get(word);
+    if (!unit) {
+      unknownUnit = word;
+      return match;
+    }
+    total += Number(amount) * UNIT_SECONDS[unit];
+    return '';
+  });
+  if (unknownUnit) {
+    throw new Error(`Unknown time unit "${unknownUnit}". Use d, h, m or s, e.g. "2h 30m".`);
+  }
+  if (leftovers.replace(/[\s,]+/g, '') !== '') {
+    throw new Error(`Could not understand "${text}". Try "2h 30m", "45m" or "90" (minutes).`);
+  }
+  if (total <= 0) throw new Error('Duration must be greater than zero.');
+  return total;
+}
+
+/**
+ * Parse a 24h clock time ("14:30") into the next Date it occurs
+ * (today if still ahead, otherwise tomorrow).
+ */
+export function parseClockTime(text, now = new Date()) {
+  const match = /^([01]?\d|2[0-3]):([0-5]\d)$/.exec(String(text ?? '').trim());
+  if (!match) throw new Error(`"${text}" is not a valid time. Use 24h format, e.g. "14:30".`);
+  const at = new Date(now);
+  at.setHours(Number(match[1]), Number(match[2]), 0, 0);
+  if (at.getTime() <= now.getTime()) at.setDate(at.getDate() + 1);
+  return at;
+}
+
+export function formatDuration(totalSeconds) {
+  const s = Math.max(0, Math.round(totalSeconds));
+  const days = Math.floor(s / 86400);
+  const hours = Math.floor((s % 86400) / 3600);
+  const minutes = Math.floor((s % 3600) / 60);
+  const seconds = s % 60;
+  const parts = [];
+  if (days) parts.push(`${days}d`);
+  if (hours) parts.push(`${hours}h`);
+  if (minutes) parts.push(`${minutes}m`);
+  if (!parts.length || (seconds && !days && !hours)) parts.push(`${seconds}s`);
+  return parts.join(' ');
+}
+
+export function timeAgo(date, now = new Date()) {
+  const s = Math.max(0, (now.getTime() - new Date(date).getTime()) / 1000);
+  if (s < 60) return 'just now';
+  if (s < 3600) return `${Math.floor(s / 60)}m ago`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h ago`;
+  return `${Math.floor(s / 86400)}d ago`;
+}
+
+export function describeRunAt(runAt, now = new Date()) {
+  const at = new Date(runAt);
+  const delta = (at.getTime() - now.getTime()) / 1000;
+  if (delta <= -60) return `due ${formatDuration(-delta)} ago`;
+  if (delta < 60) return 'now';
+  const clock = at.toLocaleString(undefined, {
+    hour: '2-digit',
+    minute: '2-digit',
+    day: '2-digit',
+    month: 'short',
+  });
+  return `in ${formatDuration(delta)} (${clock})`;
+}

package/lib/tui.js

@@ -0,0 +1,187 @@
+import { createInterface, emitKeypressEvents } from 'node:readline';
+
+const useColor = (stream = process.stdout) => Boolean(stream.isTTY) && !('NO_COLOR' in process.env);
+
+const paint = (code, close = 39) => (text, stream) =>
+  useColor(stream) ? `\x1b[${code}m${text}\x1b[${close}m` : String(text);
+
+export const color = {
+  bold: paint(1, 22),
+  dim: paint(2, 22),
+  red: paint(31),
+  green: paint(32),
+  yellow: paint(33),
+  cyan: paint(36),
+  magenta: paint(35),
+};
+
+/**
+ * Arrow-key select menu. Returns the chosen value, or null when the user
+ * cancels (esc / ctrl+c / q). Choices are strings or
+ * { label, value, hint } objects. Long lists scroll inside `pageSize`.
+ */
+export function select(message, choices, {
+  stdin = process.stdin,
+  stdout = process.stdout,
+  pageSize = 10,
+} = {}) {
+  const items = choices.map((choice) =>
+    typeof choice === 'string' ? { label: choice, value: choice } : choice,
+  );
+  if (!items.length) return Promise.resolve(null);
+  return new Promise((resolvePromise) => {
+    let index = 0;
+    let top = 0;
+    let renderedLines = 0;
+    emitKeypressEvents(stdin);
+    const raw = typeof stdin.setRawMode === 'function';
+    if (raw) stdin.setRawMode(true);
+    stdin.resume();
+    if (stdout.isTTY) stdout.write('\x1b[?25l');
+
+    const render = () => {
+      if (renderedLines) stdout.write(`\x1b[${renderedLines}A`);
+      if (stdout.isTTY) stdout.write('\x1b[0J');
+      const lines = [
+        `${color.green('?', stdout)} ${color.bold(message, stdout)} ${color.dim('(↑/↓ · enter · esc cancels)', stdout)}`,
+      ];
+      if (top > 0) lines.push(color.dim(`    ↑ ${top} more`, stdout));
+      const end = Math.min(items.length, top + pageSize);
+      for (let i = top; i < end; i += 1) {
+        const item = items[i];
+        const active = i === index;
+        const pointer = active ? color.cyan('❯', stdout) : ' ';
+        const label = active ? color.cyan(item.label, stdout) : item.label;
+        const hint = item.hint ? ` ${color.dim(item.hint, stdout)}` : '';
+        lines.push(`  ${pointer} ${label}${hint}`);
+      }
+      if (end < items.length) lines.push(color.dim(`    ↓ ${items.length - end} more`, stdout));
+      renderedLines = lines.length;
+      stdout.write(`${lines.join('\n')}\n`);
+    };
+
+    const finish = (value) => {
+      stdin.removeListener('keypress', onKeypress);
+      if (raw) stdin.setRawMode(false);
+      stdin.pause();
+      if (stdout.isTTY) {
+        stdout.write(`\x1b[${renderedLines}A\x1b[0J`);
+        const answer = value === null
+          ? color.dim('cancelled', stdout)
+          : color.cyan(items[index].label, stdout);
+        stdout.write(`${color.green('✔', stdout)} ${color.bold(message, stdout)} ${answer}\n`);
+        stdout.write('\x1b[?25h');
+      }
+      resolvePromise(value);
+    };
+
+    const move = (delta) => {
+      index = (index + delta + items.length) % items.length;
+      if (index < top) top = index;
+      if (index >= top + pageSize) top = index - pageSize + 1;
+      render();
+    };
+
+    const onKeypress = (str, key = {}) => {
+      if (key.name === 'up' || str === 'k') move(-1);
+      else if (key.name === 'down' || str === 'j') move(1);
+      else if (key.name === 'return' || key.name === 'enter') finish(items[index].value);
+      else if (key.name === 'escape' || str === 'q' || (key.ctrl && key.name === 'c')) finish(null);
+      else if (/^[1-9]$/.test(str ?? '') && Number(str) <= items.length) {
+        // Highlight only — instant-select would let a pasted answer like
+        // "2h 30m" pick item 2 and leak "h 30m" into the next prompt.
+        index = Number(str) - 1;
+        top = Math.max(0, Math.min(index, items.length - pageSize));
+        render();
+      }
+    };
+
+    stdin.on('keypress', onKeypress);
+    render();
+  });
+}
+
+/**
+ * Free-text prompt. Returns the value (trimmed), the default when the
+ * answer is empty, or null when cancelled with ctrl+c.
+ */
+export async function input(message, {
+  def,
+  required = false,
+  validate,
+  stdin = process.stdin,
+  stdout = process.stdout,
+} = {}) {
+  const rl = createInterface({ input: stdin, output: stdout });
+  // Queue lines instead of using rl.question(): fast input (or a paste with
+  // newlines) can deliver several lines in one chunk, and question() drops
+  // every line it is not currently waiting for.
+  const lines = [];
+  let waiter = null;
+  let closed = false;
+  rl.on('line', (line) => {
+    if (waiter) {
+      const deliver = waiter;
+      waiter = null;
+      deliver(line);
+    } else {
+      lines.push(line);
+    }
+  });
+  rl.on('close', () => {
+    closed = true;
+    if (waiter) {
+      const deliver = waiter;
+      waiter = null;
+      deliver(null);
+    }
+  });
+  rl.on('SIGINT', () => rl.close());
+  const suffix = def ? ` ${color.dim(`(${def})`, stdout)}` : '';
+  const question = `${color.green('?', stdout)} ${color.bold(message, stdout)}${suffix} `;
+  const ask = () => {
+    rl.setPrompt(question);
+    rl.prompt();
+    if (lines.length) return Promise.resolve(lines.shift());
+    if (closed) return Promise.resolve(null);
+    return new Promise((resolveLine) => {
+      waiter = resolveLine;
+    });
+  };
+  try {
+    for (;;) {
+      const answer = await ask();
+      if (answer === null) {
+        stdout.write('\n');
+        return null;
+      }
+      const value = answer.trim() || def || '';
+      if (required && !value) {
+        stdout.write(color.red('  This field is required.\n', stdout));
+        continue;
+      }
+      if (validate && value !== '') {
+        const error = validate(value);
+        if (error) {
+          stdout.write(color.red(`  ${error}\n`, stdout));
+          continue;
+        }
+      }
+      return value;
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+/** Yes/no prompt. Returns boolean, or null when cancelled. */
+export async function confirm(message, { def = false, stdin, stdout } = {}) {
+  const answer = await input(`${message} ${color.dim(def ? '[Y/n]' : '[y/N]')}`, {
+    stdin,
+    stdout,
+    validate: (value) => (/^(y|yes|n|no)$/i.test(value) ? null : 'Answer "y" or "n".'),
+  });
+  if (answer === null) return null;
+  if (answer === '') return def;
+  return /^y/i.test(answer);
+}

package/lib/wizard.js

@@ -0,0 +1,264 @@
+import { homedir } from 'node:os';
+import { buildCommand, commandPreview, configPath, detectAgents, loadAgents } from './agents.js';
+import {
+  cancelJob,
+  clearJobs,
+  displayStatus,
+  findPendingForSession,
+  listJobs,
+  scheduleJob,
+} from './jobs.js';
+import { listSessions } from './sessions.js';
+import { describeRunAt, parseClockTime, parseDuration, timeAgo } from './time.js';
+import { color, confirm, input, select } from './tui.js';
+
+const DEFAULT_RESUME_PROMPT = 'continue';
+
+/** Interactive console. `io` lets tests inject stdin/stdout. */
+export async function runWizard({ version = '', io = {}, env = process.env } = {}) {
+  const out = io.stdout ?? process.stdout;
+  out.write(`\n${color.bold('codewake')}${version ? color.dim(` v${version}`) : ''} ${color.dim('— schedule your coding agents to pick up where they left off')}\n\n`);
+  for (;;) {
+    const action = await select('What do you want to do?', [
+      { label: 'Schedule a resume job', value: 'schedule', hint: 'pick agent → session → prompt → time' },
+      { label: 'View jobs', value: 'jobs' },
+      { label: 'Cancel a job', value: 'cancel' },
+      { label: 'Clean up finished jobs', value: 'clear' },
+      { label: 'Exit', value: 'exit' },
+    ], io);
+    if (!action || action === 'exit') {
+      out.write(color.dim('Bye!\n'));
+      return;
+    }
+    if (action === 'schedule') await scheduleFlow({ io, env, out });
+    else if (action === 'jobs') viewJobs(out, env);
+    else if (action === 'cancel') await cancelFlow({ io, env, out });
+    else if (action === 'clear') {
+      const removed = clearJobs(env);
+      out.write(removed.length
+        ? `${color.green('✔')} Removed ${removed.length} finished job${removed.length === 1 ? '' : 's'}.\n\n`
+        : color.dim('Nothing to clean up.\n\n'));
+    }
+  }
+}
+
+async function scheduleFlow({ io, env, out }) {
+  const detected = detectAgents(loadAgents({ env }), { env });
+  const installed = detected.filter((entry) => entry.bin);
+  if (!installed.length) {
+    out.write(`${color.yellow('!')} No supported agents found on your PATH.\n`);
+    out.write(color.dim(`  Known agents: ${detected.map((entry) => entry.agent.bins[0]).join(', ')}\n`));
+    out.write(color.dim(`  Add your own in ${configPath(env)}\n\n`));
+    return;
+  }
+
+  const picked = await select('Which agent do you want to launch?', installed.map((entry) => ({
+    label: entry.agent.name,
+    value: entry,
+    hint: `(${entry.bin})`,
+  })), io);
+  if (!picked) return;
+  const { agent, bin } = picked;
+
+  // Session: existing, manual id, or brand new.
+  let mode = 'create';
+  let sessionId = null;
+  if (agent.resume) {
+    const sessions = listSessions(agent, { project: process.cwd(), home: env.HOME || homedir() });
+    const choices = sessions.slice(0, 25).map((session) => ({
+      label: session.title,
+      value: { mode: 'resume', sessionId: session.id },
+      hint: `${session.id.slice(0, 8)} · ${timeAgo(session.updatedAt)}`,
+    }));
+    choices.push({ label: 'Enter a session id manually', value: { mode: 'manual' } });
+    if (agent.create) choices.push({ label: 'Start a new session', value: { mode: 'create' } });
+    const chosen = await select(
+      sessions.length ? `Which session do you want to resume?` : `No sessions found for ${agent.name} here — what now?`,
+      choices,
+      io,
+    );
+    if (!chosen) return;
+    if (chosen.mode === 'manual') {
+      const manual = await input('Session id', { required: true, ...io });
+      if (manual === null) return;
+      mode = 'resume';
+      sessionId = manual;
+    } else {
+      mode = chosen.mode;
+      sessionId = chosen.sessionId ?? null;
+    }
+  } else {
+    out.write(color.dim(`  ${agent.name} only supports starting new sessions from here.\n`));
+  }
+
+  // Two jobs resuming the same session would race each other — refuse early.
+  const duplicate = findPendingForSession(agent.id, sessionId, env);
+  if (duplicate) {
+    out.write(`${color.yellow('!')} This session already has a pending job (${color.bold(duplicate.id)}, ${describeRunAt(duplicate.runAt)}).\n`);
+    out.write(color.dim(`  Cancel it first if you want to reschedule: codewake cancel ${duplicate.id}\n\n`));
+    return;
+  }
+
+  // Prompt: optional when resuming (defaults to "continue"), required for new sessions.
+  const prompt = mode === 'resume'
+    ? await input('Prompt to send', { def: DEFAULT_RESUME_PROMPT, ...io })
+    : await input('Prompt for the new session', { required: true, ...io });
+  if (prompt === null) return;
+
+  // Permissions.
+  const spec = mode === 'resume' ? agent.resume : agent.create;
+  let skipPermissions = false;
+  if (spec.skip) {
+    const answer = await confirm('Skip permission prompts? (the agent will run fully unattended)', { def: false, ...io });
+    if (answer === null) return;
+    skipPermissions = answer;
+  }
+
+  // When to launch.
+  const runAt = await askWhen(io);
+  if (runAt === null) return;
+
+  const args = buildCommand(agent, { mode, sessionId, prompt, skipPermissions });
+  const project = process.cwd();
+
+  out.write(`\n${color.bold('Summary')}\n`);
+  out.write(`  ${color.dim('Agent')}        ${agent.name}\n`);
+  out.write(`  ${color.dim('Session')}      ${mode === 'resume' ? sessionId : 'new session'}\n`);
+  out.write(`  ${color.dim('Prompt')}       ${prompt}\n`);
+  out.write(`  ${color.dim('Permissions')}  ${skipPermissions ? color.yellow('skipped (unattended)') : 'interactive'}\n`);
+  out.write(`  ${color.dim('Launch')}       ${describeRunAt(runAt)}\n`);
+  out.write(`  ${color.dim('Project')}      ${project}\n`);
+  out.write(`  ${color.dim('Command')}      ${commandPreview(bin, args)}\n\n`);
+
+  const go = await confirm('Schedule it?', { def: true, ...io });
+  if (!go) {
+    out.write(color.dim('Discarded.\n\n'));
+    return;
+  }
+  let job;
+  try {
+    job = scheduleJob({ agent, bin, args, mode, sessionId, prompt, skipPermissions, project, runAt }, { env });
+  } catch (error) {
+    out.write(`${color.red('✘')} ${error.message}\n\n`);
+    return;
+  }
+  out.write(`${color.green('✔')} Job ${color.bold(job.id)} scheduled ${describeRunAt(job.runAt)}.\n`);
+  out.write(color.dim(`  Manage it with "codewake jobs", "codewake logs ${job.id}" or "codewake cancel ${job.id}".\n\n`));
+}
+
+async function askWhen(io) {
+  const kind = await select('When should it launch?', [
+    { label: 'Right now', value: 'now' },
+    { label: 'After a delay', value: 'in', hint: 'e.g. 2h 30m' },
+    { label: 'At a specific time', value: 'at', hint: 'e.g. 14:30' },
+  ], io);
+  if (!kind) return null;
+  if (kind === 'now') return new Date();
+  if (kind === 'in') {
+    const text = await input('Delay', {
+      required: true,
+      validate: (value) => tryError(() => parseDuration(value)),
+      ...io,
+    });
+    if (text === null) return null;
+    return new Date(Date.now() + parseDuration(text) * 1000);
+  }
+  const text = await input('Time (24h)', {
+    required: true,
+    validate: (value) => tryError(() => parseClockTime(value)),
+    ...io,
+  });
+  if (text === null) return null;
+  return parseClockTime(text);
+}
+
+function tryError(fn) {
+  try {
+    fn();
+    return null;
+  } catch (error) {
+    return error.message;
+  }
+}
+
+export function viewJobs(out, env = process.env) {
+  const jobs = listJobs(env);
+  if (!jobs.length) {
+    out.write(color.dim('No jobs yet. Schedule one first.\n\n'));
+    return;
+  }
+  out.write(`${renderJobsTable(jobs, Date.now(), { width: out.columns })}\n\n`);
+}
+
+/** Shorten a path for display: home becomes ~, long paths keep their tail. */
+export function shortenPath(path, max, home = homedir()) {
+  let short = path;
+  if (home && short.startsWith(home)) short = `~${short.slice(home.length)}`;
+  if (short.length > max) short = `…${short.slice(short.length - max + 1)}`;
+  return short;
+}
+
+const truncate = (text, max) =>
+  (text.length > max ? `${text.slice(0, Math.max(0, max - 1))}…` : text);
+
+/**
+ * Fixed-width jobs table that always fits `width` columns: the PROJECT
+ * column absorbs the remaining space (shortened from the left), and is
+ * dropped entirely when the terminal is too narrow for it.
+ */
+export function renderJobsTable(jobs, now = Date.now(), { width = process.stdout.columns || 120 } = {}) {
+  const statusColor = { pending: color.cyan, running: color.yellow, done: color.green, failed: color.red, cancelled: color.dim, overdue: color.red };
+  const rows = jobs.map((job) => [
+    job.id,
+    truncate(job.agentName, 20),
+    displayStatus(job, now),
+    truncate(job.status === 'pending' ? describeRunAt(job.runAt, new Date(now)) : new Date(job.runAt).toLocaleString(), 28),
+    job.mode === 'resume' ? truncate(job.sessionId ?? '', 12) : 'new session',
+    job.project,
+  ]);
+  let header = ['ID', 'AGENT', 'STATUS', 'LAUNCH', 'SESSION', 'PROJECT'];
+  const columnWidth = (column) =>
+    Math.max(header[column].length, ...rows.map((row) => String(row[column]).length));
+  const gap = 2;
+  const fixedWidth = header.slice(0, -1).reduce((sum, _title, column) => sum + columnWidth(column) + gap, 0);
+  const projectSpace = width - fixedWidth;
+  if (projectSpace >= 'PROJECT'.length) {
+    for (const row of rows) row[5] = shortenPath(row[5], projectSpace);
+  } else {
+    header = header.slice(0, 5);
+    for (const row of rows) row.length = 5;
+  }
+  const widths = header.map((_title, column) => columnWidth(column));
+  const line = (cells, decorate) => cells
+    .map((cell, column) => {
+      const text = String(cell).padEnd(widths[column]);
+      return decorate && column === 2 ? (statusColor[cell] ?? color.dim)(text) : text;
+    })
+    .join(' '.repeat(gap))
+    .trimEnd();
+  return [color.dim(line(header)), ...rows.map((row) => line(row, true))].join('\n');
+}
+
+async function cancelFlow({ io, env, out }) {
+  const pending = listJobs(env).filter((job) => job.status === 'pending');
+  if (!pending.length) {
+    out.write(color.dim('No pending jobs to cancel.\n\n'));
+    return;
+  }
+  const jobId = await select('Which job do you want to cancel?', pending.map((job) => ({
+    label: `${job.id} · ${job.agentName}`,
+    value: job.id,
+    hint: describeRunAt(job.runAt),
+  })), io);
+  if (!jobId) return;
+  const sure = await confirm(`Cancel ${jobId}?`, { def: true, ...io });
+  if (!sure) return;
+  try {
+    const { warning } = cancelJob(jobId, env);
+    out.write(`${color.green('✔')} Cancelled ${jobId}.\n`);
+    if (warning) out.write(`${color.yellow('!')} ${warning}\n`);
+    out.write('\n');
+  } catch (error) {
+    out.write(`${color.red('✘')} ${error.message}\n\n`);
+  }
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "codewake",
+  "version": "0.0.1",
+  "description": "Interactive CLI to schedule your coding agents (Claude Code, Codex, Copilot, Gemini, Cursor, Aider, ...) to wake up and pick up where they left off.",
+  "keywords": [
+    "cli",
+    "agents",
+    "scheduler",
+    "resume",
+    "codewake",
+    "claude-code",
+    "codex",
+    "copilot",
+    "gemini",
+    "cursor",
+    "aider",
+    "opencode",
+    "goose"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "codewake": "bin/codewake.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "os": [
+    "linux",
+    "darwin",
+    "win32"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/luisobz/codewake.git"
+  },
+  "bugs": {
+    "url": "https://github.com/luisobz/codewake/issues"
+  },
+  "homepage": "https://github.com/luisobz/codewake#readme",
+  "scripts": {
+    "test": "node --test",
+    "update:version": "npm version patch --no-git-tag-version",
+    "build": "node -e \"\"",
+    "publish:npm": "pnpm run test && pnpm run update:version && pnpm run build && pnpm publish --access public",
+    "git:tag": "git commit -am \"v$npm_package_version\" && git push origin main && git tag v$npm_package_version && git push origin v$npm_package_version"
+  }
+}