codewake 0.0.1 → 0.0.2

package/lib/cli.js

@@ -1,21 +1,28 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { buildCommand, commandPreview, detectAgents, loadAgents } from './agents.js';
+import {
+  attachOpen,
+  DEFAULT_RESUME_PROMPT,
+  prepareOpen,
+  retryFromSpec,
+  scheduleFromSpec,
+} from './actions.js';
 import {
   cancelJob,
   clearJobs,
-  listJobs,
+  displayStatus,
+  loadJob,
   logFile,
   runJob,
-  scheduleJob,
   waitJob,
 } from './jobs.js';
-import { describeRunAt, parseClockTime, parseDuration } from './time.js';
+import { describeRunAt } from './time.js';
 import { color } from './tui.js';
 import { runWizard, viewJobs } from './wizard.js';
 
-const DEFAULT_RESUME_PROMPT = 'continue';
+export { resolveRunAt } from './actions.js';
+
 const PACKAGE_JSON = fileURLToPath(new URL('../package.json', import.meta.url));
 
 export function version() {
@@ -29,8 +36,10 @@ Usage:
   codewake                     Interactive console (detect agents, pick a
                                session, schedule the resume job)
   codewake jobs                List scheduled and finished jobs
-  codewake logs <job-id>       Show the output of a job
+  codewake open <job-id>       Reopen a job's session in its agent's own UI
+  codewake logs <job-id>       Show a job's status and output
   codewake cancel <job-id>     Cancel a pending job
+  codewake retry <job-id>      Reschedule a failed, finished or overdue job
   codewake clear               Remove finished jobs from the list
   codewake agents              Show which agents are installed
   codewake schedule [options]  Non-interactive scheduling
@@ -49,10 +58,16 @@ Schedule options:
   --bin <path>          Override the detected executable
   --dry-run             Print what would run without scheduling
 
+Retry options:
+  --now | --in <duration> | --at <HH:MM>   When to launch again (default: now)
+  --prompt <text>                          Override the prompt to send
+  --project <dir>                          Override the working directory
+
 Examples:
   codewake
   codewake schedule --agent claude --session 550e8400 --in 2h30m
-  codewake schedule --agent codex --new --prompt "run the test suite" --at 06:00`;
+  codewake schedule --agent codex --new --prompt "run the test suite" --at 06:00
+  codewake retry mrouq7ln-rkv5 --in 5s`;
 }
 
 export function parseArgs(argv) {
@@ -79,6 +94,11 @@ export function parseArgs(argv) {
     case 'cancel':
       if (!rest[0]) throw new Error('Usage: codewake cancel <job-id>');
       return { command: 'cancel', jobId: rest[0] };
+    case 'open':
+      if (!rest[0]) throw new Error('Usage: codewake open <job-id>');
+      return { command: 'open', jobId: rest[0] };
+    case 'retry':
+      return parseRetryArgs(rest);
     case 'schedule':
       return parseScheduleArgs(rest);
     case '--run':
@@ -129,43 +149,41 @@ function parseScheduleArgs(argv) {
   return result;
 }
 
-export function resolveRunAt(when, now = new Date()) {
-  if (when.type === 'in') return new Date(now.getTime() + parseDuration(when.value) * 1000);
-  if (when.type === 'at') return parseClockTime(when.value, now);
-  return now;
-}
-
-function scheduleFromArgs(args, env = process.env) {
-  const detected = detectAgents(loadAgents({ env }), { env });
-  const entry = detected.find((candidate) => candidate.agent.id === args.agentId);
-  if (!entry) {
-    const known = detected.map((candidate) => candidate.agent.id).join(', ');
-    throw new Error(`Unknown agent "${args.agentId}". Known agents: ${known}.`);
+function parseRetryArgs(argv) {
+  const [jobId, ...rest] = argv;
+  if (!jobId || jobId.startsWith('-')) {
+    throw new Error('Usage: codewake retry <job-id> [--now | --in <duration> | --at <HH:MM>]');
   }
-  const bin = args.bin ?? entry.bin;
-  if (!bin) {
-    throw new Error(`${entry.agent.name} is not installed (looked for: ${entry.agent.bins.join(', ')}). Use --bin to point at it.`);
+  const result = { command: 'retry', jobId, when: { type: 'now' }, prompt: null, project: null, dryRun: false };
+  const value = (i, flag) => {
+    if (rest[i + 1] === undefined) throw new Error(`${flag} needs a value.`);
+    return rest[i + 1];
+  };
+  for (let i = 0; i < rest.length; i += 1) {
+    const flag = rest[i];
+    if (flag === '--in') result.when = { type: 'in', value: value(i, flag) }, i += 1;
+    else if (flag === '--at') result.when = { type: 'at', value: value(i, flag) }, i += 1;
+    else if (flag === '--now') result.when = { type: 'now' };
+    else if (flag === '--prompt') result.prompt = value(i, flag), i += 1;
+    else if (flag === '--project') result.project = resolve(value(i, flag)), i += 1;
+    else if (flag === '--dry-run') result.dryRun = true;
+    else throw new Error(`Unknown option: ${flag}. Run "codewake --help".`);
   }
-  const mode = args.isNew ? 'create' : 'resume';
-  const prompt = args.prompt?.trim() || DEFAULT_RESUME_PROMPT;
-  const commandArgs = buildCommand(entry.agent, {
-    mode,
-    sessionId: args.sessionId,
-    prompt,
-    skipPermissions: args.skipPermissions,
-  });
-  const job = scheduleJob({
-    agent: entry.agent,
-    bin,
-    args: commandArgs,
-    mode,
-    sessionId: args.sessionId,
-    prompt,
-    skipPermissions: args.skipPermissions,
-    project: args.project,
-    runAt: resolveRunAt(args.when),
-  }, { dryRun: args.dryRun, env });
-  return { job, preview: commandPreview(bin, commandArgs) };
+  return result;
+}
+
+/** Status header shown by "codewake logs", separate from the raw output. */
+export function describeJobHeader(job, now = Date.now()) {
+  const outcome = [
+    job.exitCode !== undefined && job.exitCode !== null ? `exit ${job.exitCode}` : null,
+    job.signal ? `signal ${job.signal}` : null,
+  ].filter(Boolean).join(', ');
+  const lines = [`Job ${job.id} · ${job.agentName} · ${displayStatus(job, now)}${outcome ? ` (${outcome})` : ''}`];
+  lines.push(job.startedAt
+    ? `  started ${new Date(job.startedAt).toLocaleString()} in ${job.project}`
+    : `  scheduled for ${new Date(job.runAt).toLocaleString()} in ${job.project}`);
+  if (job.error) lines.push(`  error: ${job.error}`);
+  return lines.join('\n');
 }
 
 export function renderAgentsReport(detected) {
@@ -200,11 +218,24 @@ export async function main(argv) {
       viewJobs(process.stdout);
       return;
     case 'logs': {
-      const path = logFile(args.jobId);
-      if (!existsSync(path)) {
-        throw new Error(`No log for job ${args.jobId} yet (it appears at ${path} once the job runs).`);
+      let job = null;
+      try {
+        job = loadJob(args.jobId);
+      } catch {
+        // Job record already cleared; the log may still be around.
+      }
+      const path = job?.log ?? logFile(args.jobId);
+      // Header goes to stderr so "codewake logs id > out.txt" stays clean.
+      if (job) process.stderr.write(`${color.dim(describeJobHeader(job))}\n`);
+      if (existsSync(path)) {
+        process.stdout.write(readFileSync(path, 'utf8'));
+      } else if (!job) {
+        throw new Error(`No job or log found for ${args.jobId}.`);
+      } else if (job.status === 'pending') {
+        process.stderr.write(color.dim(`No output yet — the job launches ${describeRunAt(job.runAt)}.\n`));
+      } else {
+        process.stderr.write(color.dim('The job produced no output.\n'));
       }
-      process.stdout.write(readFileSync(path, 'utf8'));
       return;
     }
     case 'cancel': {
@@ -227,8 +258,26 @@ export async function main(argv) {
     case 'wait':
       await waitJob(args.jobId);
       return;
-    case 'schedule': {
-      const { job, preview } = scheduleFromArgs(args);
+    case 'open': {
+      if (!process.stdin.isTTY) {
+        throw new Error('"codewake open" attaches an interactive UI and needs a terminal.');
+      }
+      const job = loadJob(args.jobId);
+      if (job.status === 'running') {
+        console.log(`${color.yellow('!')} Job ${job.id} is still running headless; you are opening the same session alongside it.`);
+      }
+      const prepared = prepareOpen(job);
+      if (prepared.note) console.log(`${color.yellow('!')} ${prepared.note}`);
+      console.log(color.dim(`Opening ${prepared.agent.name}: ${prepared.preview}`));
+      await attachOpen(prepared);
+      return;
+    }
+    case 'schedule':
+    case 'retry': {
+      const { job, preview, note } = args.command === 'retry'
+        ? retryFromSpec(args)
+        : scheduleFromSpec(args);
+      if (note) console.log(`${color.yellow('!')} ${note}`);
       if (args.dryRun) {
         console.log(`Would launch ${describeRunAt(job.runAt)} in ${job.project}:`);
         console.log(`  ${preview}`);
@@ -236,7 +285,7 @@ export async function main(argv) {
       }
       console.log(`${color.green('✔')} Job ${color.bold(job.id)} scheduled ${describeRunAt(job.runAt)}.`);
       console.log(color.dim(`  ${preview}`));
-      console.log(color.dim(`  Manage it with "codewake jobs" or "codewake cancel ${job.id}".`));
+      console.log(color.dim(`  Watch it with "codewake jobs" and "codewake logs ${job.id}".`));
       return;
     }
     default:

package/lib/jobs.js

@@ -12,8 +12,9 @@ import {
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { which } from './agents.js';
+import { loadAgents, which } from './agents.js';
 import { spawnAgent } from './proc.js';
+import { resolveSessionPlacement } from './sessions.js';
 
 const CLI_BIN = fileURLToPath(new URL('../bin/codewake.js', import.meta.url));
 const OVERDUE_GRACE_MS = 60_000;
@@ -161,7 +162,7 @@ export function scheduleJob(spec, { dryRun = false, env = process.env } = {}) {
   if (dryRun) return job;
   saveJob(job, env);
   try {
-    if (job.backend === 'systemd') armSystemdTimer(job, now);
+    if (job.backend === 'systemd') armSystemdTimer(job, now, env);
     else armDetachedWaiter(job, env);
   } catch (error) {
     rmSync(jobFile(job.id, env), { force: true });
@@ -180,13 +181,20 @@ export function systemdCalendarSpec(runAtMs, now = Date.now()) {
     `${pad(at.getHours())}:${pad(at.getMinutes())}:${pad(at.getSeconds())}`;
 }
 
-function armSystemdTimer(job, now) {
+function armSystemdTimer(job, now, env) {
   const result = spawnSync('systemd-run', [
     '--user',
     `--unit=${unitName(job.id)}`,
     `--on-calendar=${systemdCalendarSpec(Date.parse(job.runAt), now)}`,
+    // Transient user timers default to a 1-minute accuracy window; short
+    // delays ("--in 5s") would otherwise fire up to a minute late.
+    '--timer-property=AccuracySec=1s',
     '--collect',
     '--quiet',
+    // The unit does not inherit this process's environment: point it at the
+    // same state (and config) that scheduled the job.
+    `--setenv=CODEWAKE_STATE_DIR=${stateDir(env)}`,
+    ...(env.CODEWAKE_CONFIG ? [`--setenv=CODEWAKE_CONFIG=${resolve(env.CODEWAKE_CONFIG)}`] : []),
     process.execPath,
     CLI_BIN,
     '--run',
@@ -214,26 +222,68 @@ function armDetachedWaiter(job, env) {
   saveJob(job, env);
 }
 
+/**
+ * Re-check where a resume job must run right before launch: the project may
+ * have been moved, renamed or deleted between scheduling and firing, and the
+ * session's own store knows the directory it truly belongs to. Lookup is
+ * best effort — when nothing better is known the scheduled project stands,
+ * and the agent reports its own error if it cannot find the session.
+ */
+function placementForRun(job, env) {
+  let placement = null;
+  if (job.mode === 'resume' && job.sessionId) {
+    try {
+      const agent = loadAgents({ env }).find((candidate) => candidate.id === job.agentId);
+      if (agent) {
+        placement = resolveSessionPlacement(agent, job.sessionId, {
+          project: job.project,
+          home: env.HOME || homedir(),
+        });
+      }
+    } catch {
+      // A broken config or a session that vanished must not stop the launch.
+    }
+  }
+  const project = placement?.project ?? job.project;
+  if (!existsSync(project)) {
+    return {
+      error: `Project directory ${project} no longer exists (was it moved or renamed?). ` +
+        `Reschedule with "codewake retry ${job.id} --project <dir>".`,
+    };
+  }
+  return { project, note: placement?.note ?? null };
+}
+
 /** Launch the agent for a job right now. Resolves when the agent exits. */
 export function runJob(jobId, env = process.env) {
   const job = loadJob(jobId, env);
   if (job.status === 'cancelled') return Promise.resolve(job);
+  const placement = placementForRun(job, env);
+  if (placement.project) job.project = placement.project;
   job.status = 'running';
   job.startedAt = new Date().toISOString();
   job.log = logFile(job.id, env);
   saveJob(job, env);
   ensureDir(logsDir(env));
   const log = createWriteStream(job.log, { mode: 0o600 });
+  if (placement.note) log.write(`codewake: ${placement.note}\n`);
   return new Promise((resolvePromise) => {
     let settled = false;
     const finish = (patch) => {
       if (settled) return;
       settled = true;
+      // Failures land in the log too, so "codewake logs" always explains.
+      if (patch.error) log.write(`codewake: ${patch.error}\n`);
       Object.assign(job, patch, { finishedAt: new Date().toISOString() });
       saveJob(job, env);
-      log.end();
-      resolvePromise(job);
+      // Resolve only once the log is flushed to disk, so a "codewake logs"
+      // right after completion never reads a partial (or missing) file.
+      log.end(() => resolvePromise(job));
     };
+    if (placement.error) {
+      finish({ status: 'failed', error: placement.error });
+      return;
+    }
     let child;
     try {
       child = spawnAgent(job.bin, job.args, { cwd: job.project, stdio: ['ignore', 'pipe', 'pipe'] });
@@ -244,7 +294,8 @@ export function runJob(jobId, env = process.env) {
     child.stdout.pipe(log, { end: false });
     child.stderr.pipe(log, { end: false });
     child.on('error', (error) => finish({ status: 'failed', error: error.message }));
-    child.on('exit', (code, signal) => finish({
+    // 'close' (not 'exit') guarantees stdout/stderr finished piping first.
+    child.on('close', (code, signal) => finish({
       status: code === 0 ? 'done' : 'failed',
       exitCode: code,
       signal: signal ?? undefined,

package/lib/registry.js

@@ -12,6 +12,8 @@
  *             'goose-sessions'  | 'aider-history'  | 'manual' | 'none'
  *   resume    command spec to resume an existing session (omit if unsupported)
  *   create    command spec to start a new session (omit if unsupported)
+ *   open      command spec to reopen a session in the agent's own interactive
+ *             terminal UI, attached to the user's tty (omit if unsupported)
  *
  * Command specs:
  *   args      argv template; '{session}' and '{prompt}' are substituted as
@@ -33,6 +35,9 @@ export const BUILTIN_AGENTS = [
       args: ['-p', '{prompt}'],
       skip: ['--dangerously-skip-permissions'],
     },
+    open: {
+      args: ['--resume', '{session}'],
+    },
   },
   {
     id: 'codex',
@@ -47,6 +52,9 @@ export const BUILTIN_AGENTS = [
       args: ['exec', '{prompt}'],
       skip: ['--dangerously-bypass-approvals-and-sandbox'],
     },
+    open: {
+      args: ['resume', '{session}'],
+    },
   },
   {
     id: 'gemini',
@@ -71,6 +79,9 @@ export const BUILTIN_AGENTS = [
       args: ['-p', '{prompt}'],
       skip: ['--allow-all-tools'],
     },
+    open: {
+      args: ['--resume', '{session}'],
+    },
   },
   {
     id: 'cursor',
@@ -85,6 +96,9 @@ export const BUILTIN_AGENTS = [
       args: ['-p', '{prompt}'],
       skip: ['--force'],
     },
+    open: {
+      args: ['--resume', '{session}'],
+    },
   },
   {
     id: 'opencode',
@@ -111,6 +125,9 @@ export const BUILTIN_AGENTS = [
       args: ['--message', '{prompt}'],
       skip: ['--yes-always'],
     },
+    open: {
+      args: ['--restore-chat-history'],
+    },
   },
   {
     id: 'goose',
@@ -123,6 +140,9 @@ export const BUILTIN_AGENTS = [
     create: {
       args: ['run', '--text', '{prompt}'],
     },
+    open: {
+      args: ['session', '--name', '{session}', '--resume'],
+    },
   },
   {
     id: 'amp',
@@ -137,6 +157,9 @@ export const BUILTIN_AGENTS = [
       args: ['-x', '{prompt}'],
       skip: ['--dangerously-allow-all'],
     },
+    open: {
+      args: ['threads', 'continue', '{session}'],
+    },
   },
   {
     id: 'qwen',

package/lib/sessions.js

@@ -24,6 +24,110 @@ export function encodeClaudeProject(project) {
   return project.replace(/[^a-zA-Z0-9]/g, '-');
 }
 
+/**
+ * Look a session id up across everything the agent has stored on this
+ * machine, regardless of project. Returns:
+ *   null                        lookup is unsupported or nothing could be
+ *                               searched, so nothing can be concluded
+ *   { found: false }            the store was searched and the id is not there
+ *   { found: true, project }    found; `project` is the directory the session
+ *                               was recorded in, or null when unknown
+ */
+export function locateSession(agent, sessionId, { home = homedir() } = {}) {
+  const lookup = LOCATORS[agent.sessions];
+  if (!lookup || typeof sessionId !== 'string' || !/^[\w.-]+$/.test(sessionId)) return null;
+  try {
+    return lookup(sessionId, home);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Decide the directory a resume job must run from. Agents like Claude Code
+ * only find a session when launched from the project it belongs to, so a
+ * mismatched working directory fails with "No conversation found". Returns
+ * { project, note }; `note` explains the correction when the requested
+ * project was overridden. Throws when the session provably does not exist
+ * on this machine, or when its own directory is gone.
+ */
+export function resolveSessionPlacement(agent, sessionId, { project, home = homedir() } = {}) {
+  const requested = resolve(project);
+  const located = locateSession(agent, sessionId, { home });
+  if (!located) return { project: requested, note: null };
+  if (!located.found) {
+    throw new Error(
+      `No ${agent.name} session "${sessionId}" exists on this machine. ` +
+      'Double-check the id (run "codewake" and pick the session from the list).',
+    );
+  }
+  const actual = located.project ? resolve(located.project) : null;
+  if (!actual || actual === requested) return { project: requested, note: null };
+  if (!existsSync(actual)) {
+    throw new Error(
+      `Session ${sessionId} belongs to ${actual}, but that directory no longer exists. ` +
+      `${agent.name} can only resume it from there — restore the directory first.`,
+    );
+  }
+  return {
+    project: actual,
+    note: `Session ${sessionId} belongs to ${actual}; the job will run there instead of ${requested}.`,
+  };
+}
+
+const LOCATORS = {
+  'claude-projects': (sessionId, home) => {
+    const root = join(home, '.claude', 'projects');
+    if (!existsSync(root)) return null;
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const path = join(root, entry.name, `${sessionId}.jsonl`);
+      if (existsSync(path)) return { found: true, project: claudeCwd(path) };
+    }
+    return { found: false };
+  },
+
+  'codex-rollouts': (sessionId, home) => {
+    const root = join(home, '.codex', 'sessions');
+    if (!existsSync(root)) return null;
+    for (const { path, name } of walkFiles(root, /^rollout-.*\.jsonl$/)) {
+      const meta = firstJsonLine(path);
+      const payload = meta?.payload ?? meta;
+      const id = payload?.id
+        ?? /^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-(.+)\.jsonl$/.exec(name)?.[1];
+      if (id !== sessionId) continue;
+      return { found: true, project: typeof payload?.cwd === 'string' ? payload.cwd : null };
+    }
+    return { found: false };
+  },
+
+  'copilot-history': (sessionId, home) => {
+    const dir = join(home, '.copilot', 'history-session-state');
+    if (!existsSync(dir)) return null;
+    return { found: existsSync(join(dir, `${sessionId}.json`)), project: null };
+  },
+
+  'goose-sessions': (sessionId, home) => {
+    const dir = join(home, '.local', 'share', 'goose', 'sessions');
+    if (!existsSync(dir)) return null;
+    return { found: existsSync(join(dir, `${sessionId}.jsonl`)), project: null };
+  },
+};
+
+/** First working directory recorded inside a Claude Code session file. */
+function claudeCwd(path) {
+  for (const line of head(path).split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const entry = JSON.parse(line);
+      if (typeof entry.cwd === 'string' && entry.cwd) return entry.cwd;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
 const STRATEGIES = {
   none: () => [],
   manual: () => [],

package/lib/tui.js

@@ -15,15 +15,27 @@ export const color = {
   magenta: paint(35),
 };
 
+/** Name of the key that cancelled a prompt, e.g. 'ctrl+c', 'esc', 'q'. */
+export function cancelKeyName(str, key = {}) {
+  if (key.ctrl && key.name === 'c') return 'ctrl+c';
+  if (key.ctrl && key.name === 'd') return 'ctrl+d';
+  if (key.name === 'escape') return 'esc';
+  return str ?? key.name ?? '';
+}
+
 /**
  * Arrow-key select menu. Returns the chosen value, or null when the user
- * cancels (esc / ctrl+c / q). Choices are strings or
+ * cancels (esc / q / ctrl+c / ctrl+d). Choices are strings or
  * { label, value, hint } objects. Long lists scroll inside `pageSize`.
+ * With `cancelInfo: true` a cancellation resolves to
+ * { cancelled: true, key } instead of null, so callers can react to the
+ * specific key (the main menu's press-twice-to-exit hint needs it).
  */
 export function select(message, choices, {
   stdin = process.stdin,
   stdout = process.stdout,
   pageSize = 10,
+  cancelInfo = false,
 } = {}) {
   const items = choices.map((choice) =>
     typeof choice === 'string' ? { label: choice, value: choice } : choice,
@@ -60,7 +72,7 @@ export function select(message, choices, {
       stdout.write(`${lines.join('\n')}\n`);
     };
 
-    const finish = (value) => {
+    const finish = (value, cancelKey = null) => {
       stdin.removeListener('keypress', onKeypress);
       if (raw) stdin.setRawMode(false);
       stdin.pause();
@@ -72,7 +84,7 @@ export function select(message, choices, {
         stdout.write(`${color.green('✔', stdout)} ${color.bold(message, stdout)} ${answer}\n`);
         stdout.write('\x1b[?25h');
       }
-      resolvePromise(value);
+      resolvePromise(value === null && cancelInfo ? { cancelled: true, key: cancelKey } : value);
     };
 
     const move = (delta) => {
@@ -86,7 +98,10 @@ export function select(message, choices, {
       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 (
+        key.name === 'escape' || str === 'q'
+        || (key.ctrl && (key.name === 'c' || key.name === 'd'))
+      ) finish(null, cancelKeyName(str, key));
       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.