ticlawk 0.1.12-dev.0

package/src/core/update.mjs

@@ -0,0 +1,178 @@
+/**
+ * Self-update.
+ *
+ * Updates the npm package, refreshes the user service, and prints the new
+ * version. Default flow is interactive; `-y` skips the prompt;
+ * non-interactive without `-y` exits 1.
+ */
+
+import { existsSync, mkdirSync, readFileSync, realpathSync } from 'node:fs';
+import { spawn, spawnSync } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { AF_HOME } from './config.mjs';
+
+const PACKAGE_NAME = 'ticlawk';
+
+export function readPkgVersion() {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(readFileSync(join(here, '..', '..', 'package.json'), 'utf8'));
+    return pkg.version || '';
+  } catch {
+    return '';
+  }
+}
+
+function commandExists(command) {
+  return spawnSync('command', ['-v', command], { shell: true, stdio: 'ignore' }).status === 0;
+}
+
+export function isManagedInstall() {
+  if (process.platform === 'linux' && commandExists('systemctl')) {
+    return ['ticlawk', 'agent-freeway'].some((service) => {
+      const enabled = spawnSync('systemctl', ['--user', 'is-enabled', '--quiet', service], { stdio: 'ignore' });
+      const active = spawnSync('systemctl', ['--user', 'is-active', '--quiet', service], { stdio: 'ignore' });
+      return enabled.status === 0 || active.status === 0;
+    });
+  }
+
+  if (process.platform === 'darwin' && commandExists('launchctl')) {
+    const uid = String(process.getuid?.() || '');
+    return ['ticlawk', 'agent-freeway', 'com.ticlawk.agent-freeway'].some((label) => {
+      const service = `gui/${uid}/${label}`;
+      return spawnSync('launchctl', ['print', service], { stdio: 'ignore' }).status === 0;
+    });
+  }
+
+  return false;
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+export function startDetachedSelfUpdate({ requiredVersion = '', currentVersion = '', reason = 'update_required' } = {}) {
+  if (!isManagedInstall()) {
+    return { started: false, reason: 'unmanaged_install' };
+  }
+  if (!requiredVersion) {
+    return { started: false, reason: 'missing_required_version' };
+  }
+
+  mkdirSync(AF_HOME, { recursive: true });
+  const updateLogPath = join(AF_HOME, 'ticlawk-update.log');
+  const currentCli = getCurrentCliCommand();
+  const installerVersion = requiredVersion;
+  const script = [
+    'sleep 1',
+    `printf '%s\\n' ${shellQuote(`[${new Date().toISOString()}] update required: current=${currentVersion || 'unknown'} required=${requiredVersion || 'unknown'} installer_version=${installerVersion || 'default'} reason=${reason}`)} >> ${shellQuote(updateLogPath)}`,
+    `${currentCli} update -y >> ${shellQuote(updateLogPath)} 2>&1`,
+  ].join('; ');
+
+  const child = spawn('sh', ['-lc', script], {
+    detached: true,
+    stdio: 'ignore',
+    env: {
+      ...process.env,
+      TICLAWK_UPDATE_REASON: reason,
+      TICLAWK_REQUIRED_VERSION: requiredVersion,
+      TICLAWK_CURRENT_VERSION: currentVersion,
+      ...(installerVersion ? { TICLAWK_VERSION: installerVersion } : {}),
+      AGENT_FREEWAY_UPDATE_REASON: reason,
+      AGENT_FREEWAY_REQUIRED_VERSION: requiredVersion,
+      AGENT_FREEWAY_CURRENT_VERSION: currentVersion,
+      ...(installerVersion ? { AGENT_FREEWAY_VERSION: installerVersion } : {}),
+    },
+  });
+  child.unref();
+  return { started: true, pid: child.pid, logPath: updateLogPath };
+}
+
+function getCurrentCliCommand() {
+  const scriptPath = process.argv[1] || '';
+  if (scriptPath && existsSync(scriptPath)) {
+    return `${shellQuote(process.execPath)} ${shellQuote(realpathSync(scriptPath))}`;
+  }
+  return shellQuote('ticlawk');
+}
+
+function getNpmGlobalTiclawkBin() {
+  const prefixResult = spawnSync('npm', ['prefix', '-g'], { encoding: 'utf8' });
+  const prefix = String(prefixResult.stdout || '').trim();
+  if (!prefix) return '';
+  if (process.platform === 'win32') return join(prefix, 'ticlawk.cmd');
+  return join(prefix, 'bin', 'ticlawk');
+}
+
+function runInstalledTiclawk(args, options = {}) {
+  const npmBin = getNpmGlobalTiclawkBin();
+  if (npmBin && existsSync(npmBin)) {
+    return spawnSync(npmBin, args, options);
+  }
+  return spawnSync('ticlawk', args, options);
+}
+
+function promptYesNo(question) {
+  if (!process.stdin.isTTY) {
+    return Promise.resolve(false);
+  }
+  process.stdout.write(`${question} `);
+  return new Promise((resolveAnswer) => {
+    process.stdin.setEncoding('utf8');
+    const onData = (chunk) => {
+      process.stdin.removeListener('data', onData);
+      process.stdin.pause();
+      const answer = String(chunk).trim().toLowerCase();
+      resolveAnswer(answer === '' || answer === 'y' || answer === 'yes');
+    };
+    process.stdin.resume();
+    process.stdin.on('data', onData);
+  });
+}
+
+export async function runSelfUpdate(skipPrompt) {
+  const currentVersion = readPkgVersion();
+  const targetVersion = process.env.TICLAWK_VERSION
+    || process.env.TICLAWK_REQUIRED_VERSION
+    || process.env.AGENT_FREEWAY_VERSION
+    || process.env.AGENT_FREEWAY_REQUIRED_VERSION
+    || 'latest';
+  const packageSpec = `${PACKAGE_NAME}@${targetVersion}`;
+  console.log(`current version: ${currentVersion || '(unknown)'}`);
+  console.log(`package:         ${packageSpec}`);
+
+  if (!skipPrompt) {
+    if (!process.stdin.isTTY) {
+      console.error('refusing to update non-interactively without -y');
+      process.exit(1);
+    }
+    const ok = await promptYesNo('Update ticlawk with npm? [Y/n]');
+    if (!ok) {
+      console.log('aborted');
+      return;
+    }
+  }
+
+  const installResult = spawnSync('npm', ['install', '--global', '--no-audit', '--no-fund', packageSpec], {
+    stdio: 'inherit',
+  });
+  if (installResult.status !== 0) {
+    console.error('npm install failed');
+    process.exit(installResult.status || 1);
+  }
+
+  const readiness = runInstalledTiclawk(['setup-readiness', '--ensure-daemon'], { stdio: 'inherit' });
+  if (readiness.status !== 0) {
+    console.error('setup readiness failed');
+    process.exit(readiness.status || 1);
+  }
+
+  const newVer = runInstalledTiclawk(['version'], { encoding: 'utf8' });
+  const newVersion = (newVer.stdout || '').trim();
+  if (newVersion) {
+    console.log(`installed version: ${newVersion}`);
+  } else {
+    console.log('update complete');
+  }
+}

package/src/runtimes/claude-code/index.mjs

@@ -0,0 +1,363 @@
+/**
+ * Claude Code runtime entry point.
+ *
+ * Exposes a narrow surface an adapter can use to drive a Claude Code
+ * session without knowing anything about the `claude` binary's calling
+ * convention. The adapter decides rotation and message routing; the
+ * runtime owns the binary-level details.
+ */
+
+import { existsSync } from 'node:fs';
+import { basename } from 'node:path';
+import {
+  createCCSession,
+  getClaudeCodeRuntimeHealth,
+  runCCPrompt,
+  streamCCPrompt,
+  requireClaudePath,
+  prettyProjectName,
+  getClaudeTranscriptPath,
+  CC_PROJECTS_DIR,
+  CC_MAX_AGE_MS,
+} from './session.mjs';
+import { discoverSessions } from './transcripts.mjs';
+import { buildImageMessageFromInbound } from '../../core/media/inbound.mjs';
+import { normalizeOutboundMedia } from '../../core/media/outbound.mjs';
+import { emitWorkerEvent } from '../../core/events/worker-events.mjs';
+import {
+  shouldStreamRuntime,
+  sendAdapterMessage,
+  sendResult,
+  reportSubprocessFailure,
+  terminalRuntimeFailure,
+  updateBindingRuntimeMeta,
+} from '../../core/runtime-support.mjs';
+
+export const claudeCodeRuntime = {
+  name: 'claude_code',
+
+  // Start a new Claude session without blocking on local transcript
+  // discovery. The live turn path trusts stdout/session_id; transcript
+  // indexing is a separate concern.
+  async createSession({ projectDir, text, claudePath }) {
+    return createCCSession({ projectDir, message: text, claudePath });
+  },
+
+  // Run a Claude turn and wait for the final result on stdout. This is
+  // the worker-first path used by the adapter for direct reply delivery.
+  runTurn({ sessionId, projectDir, claudePath }, text, opts = {}) {
+    return runCCPrompt({ sessionId, projectDir, message: text, claudePath, timeoutMs: opts.timeoutMs });
+  },
+
+  runTurnStream({ sessionId, projectDir, claudePath }, text, opts = {}) {
+    return streamCCPrompt({
+      sessionId,
+      projectDir,
+      message: text,
+      claudePath,
+      timeoutMs: opts.timeoutMs,
+      onEvent: opts.onEvent,
+    });
+  },
+
+  // Enumerate local CC sessions from disk. Used by adapter setup / bind
+  // flows to verify a sessionId exists locally before creating or
+  // updating a binding. Each session carries enough metadata for the
+  // adapter to round-trip it back into backend-specific channel meta.
+  async listLocalSessions() {
+    return discoverSessions(CC_PROJECTS_DIR);
+  },
+
+  async resolveBinding(payload) {
+    const requestedProjectDir = String(payload?.projectDir || payload?.workdir || payload?.cwd || '').trim();
+    const claudePath = requireClaudePath(payload?.claudePath || payload?.runtimePath);
+    const claudeVersion = getClaudeCodeRuntimeHealth(claudePath).version;
+
+    if (payload?.sessionId) {
+      const sessions = await this.listLocalSessions();
+      const session = sessions.find((entry) => entry.sessionId === payload.sessionId);
+      if (!session) {
+        throw new Error('session not found locally');
+      }
+      return {
+        runtime: this.name,
+        displayName: payload?.name || this.formatDisplayName(session) || basename(session.projectDir || '') || 'Claude Code',
+        runtimeMeta: {
+          sessionId: session.sessionId,
+          project: session.project,
+          workdir: session.projectDir,
+          projectDir: session.projectDir,
+          path: session.path,
+          runtimePath: claudePath,
+          claudePath,
+          claudeVersion,
+          rotatePending: false,
+        },
+      };
+    }
+
+    if (!requestedProjectDir) {
+      throw new Error('projectDir or sessionId is required for claude_code binding');
+    }
+    if (!existsSync(requestedProjectDir)) {
+      throw new Error(`project dir not found locally: ${requestedProjectDir}`);
+    }
+
+    return {
+      runtime: this.name,
+      displayName: payload?.name || basename(requestedProjectDir) || 'Claude Code',
+      runtimeMeta: {
+        sessionId: null,
+        project: basename(requestedProjectDir) || '',
+        workdir: requestedProjectDir,
+        projectDir: requestedProjectDir,
+        path: null,
+        runtimePath: claudePath,
+        claudePath,
+        claudeVersion,
+        rotatePending: false,
+      },
+    };
+  },
+
+  async health(meta = {}) {
+    return getClaudeCodeRuntimeHealth(meta?.claudePath || meta?.runtimePath);
+  },
+
+  async deliverTurn(inbound, ctx) {
+    const binding = ctx.getBinding(inbound.bindingId);
+    if (!binding) return false;
+    const adapter = ctx.adapter;
+    const meta = binding.runtimeMeta || {};
+    const projectDir = meta.projectDir;
+    const sessionId = meta.sessionId || binding.id;
+    const runtimeClaudePath = meta.claudePath || meta.runtimePath || null;
+
+    if (!projectDir || !existsSync(projectDir)) {
+      await sendAdapterMessage(adapter, binding, {
+        type: 'assistant',
+        text: `⚠️ Claude Code project dir not found: ${projectDir || '(missing)'}`,
+        media: [],
+        replyToMessageId: inbound.messageId || null,
+      });
+      return true;
+    }
+
+    const message = inbound.action === 'image'
+      ? await buildImageMessageFromInbound(inbound, 'claude-code')
+      : inbound.text;
+
+    const shouldRotate = !meta.sessionId || meta.rotatePending;
+    if (shouldRotate) {
+      await emitWorkerEvent({
+        adapter,
+        binding,
+        agent: this.name,
+        sessionId: sessionId || binding.id,
+        cwd: projectDir,
+        replyToMessageId: inbound.messageId || null,
+        event: {
+          hook_event_name: 'worker.turn.start',
+          worker_event_name: 'worker.turn.start',
+        },
+        logger: ctx.logger,
+      });
+      try {
+        const claudePath = requireClaudePath(runtimeClaudePath);
+        const claudeVersion = getClaudeCodeRuntimeHealth(claudePath).version || meta.claudeVersion || null;
+        const created = await this.createSession({ projectDir, text: message, claudePath });
+        const nextBinding = await updateBindingRuntimeMeta(ctx, binding, {
+          sessionId: created.sessionId,
+          projectDir,
+          path: null,
+          runtimePath: claudePath,
+          claudePath,
+          claudeVersion,
+          rotatePending: false,
+          lastRotatedAt: new Date().toISOString(),
+        }, { status: 'connected' });
+        if (created.resultText && created.resultText.trim()) {
+          await sendAdapterMessage(adapter, nextBinding, {
+            type: 'assistant',
+            text: created.resultText,
+            media: [],
+            replyToMessageId: inbound.messageId || null,
+          });
+        }
+        await emitWorkerEvent({
+          adapter,
+          binding: nextBinding,
+          agent: this.name,
+          sessionId: created.sessionId,
+          cwd: projectDir,
+          replyToMessageId: inbound.messageId || null,
+          event: {
+            hook_event_name: 'Stop',
+            worker_event_name: 'worker.turn.complete',
+          },
+          logger: ctx.logger,
+        });
+        return true;
+      } catch (err) {
+        await emitWorkerEvent({
+          adapter,
+          binding,
+          agent: this.name,
+          sessionId: sessionId || binding.id,
+          cwd: projectDir,
+          replyToMessageId: inbound.messageId || null,
+          event: {
+            hook_event_name: 'worker.turn.error',
+            worker_event_name: 'worker.turn.error',
+            error: err?.message || 'Claude Code failed',
+          },
+          logger: ctx.logger,
+        });
+        await reportSubprocessFailure({
+          adapter,
+          binding,
+          inbound,
+          runtimeName: 'Claude Code',
+          info: err?.info || {
+            ok: false,
+            kind: 'exit-error',
+            errorMessage: err?.message || 'Claude Code failed',
+            durationMs: 0,
+          },
+        });
+        return terminalRuntimeFailure(err?.message || 'Claude Code failed');
+      }
+    }
+
+    try {
+      const claudePath = requireClaudePath(runtimeClaudePath);
+      const claudeVersion = getClaudeCodeRuntimeHealth(claudePath).version || meta.claudeVersion || null;
+      const result = shouldStreamRuntime(this.name, this)
+        ? await this.runTurnStream({ sessionId, projectDir, claudePath }, message, {
+            onEvent: async (event) => {
+              if (event?.type === 'turn.started') {
+                await emitWorkerEvent({
+                  adapter,
+                  binding,
+                  agent: this.name,
+                  sessionId: event.sessionId || sessionId,
+                  cwd: projectDir,
+                  replyToMessageId: inbound.messageId || null,
+                  event: {
+                    hook_event_name: 'worker.turn.start',
+                    worker_event_name: 'worker.turn.start',
+                  },
+                  logger: ctx.logger,
+                });
+              } else if (event?.type === 'message.delta' && event.text) {
+                await emitWorkerEvent({
+                  adapter,
+                  binding,
+                  agent: this.name,
+                  sessionId: event.sessionId || sessionId,
+                  cwd: projectDir,
+                  replyToMessageId: inbound.messageId || null,
+                  event: {
+                    hook_event_name: 'worker.message.delta',
+                    worker_event_name: 'worker.message.delta',
+                    delta: event.text,
+                  },
+                  logger: ctx.logger,
+                });
+              }
+            },
+          })
+        : await this.runTurn({ sessionId, projectDir, claudePath }, message);
+      const nextBinding = await updateBindingRuntimeMeta(ctx, binding, {
+        sessionId: result?.sessionId || meta.sessionId,
+        runtimePath: claudePath,
+        claudePath,
+        claudeVersion,
+      }, { status: 'connected' });
+      await sendResult(adapter, nextBinding, inbound, {
+        ...result,
+        media: normalizeOutboundMedia(result),
+      });
+      await emitWorkerEvent({
+        adapter,
+        binding: nextBinding,
+        agent: this.name,
+        sessionId: result?.sessionId || sessionId,
+        cwd: projectDir,
+        replyToMessageId: inbound.messageId || null,
+        event: {
+          hook_event_name: 'Stop',
+          worker_event_name: 'worker.turn.complete',
+        },
+        logger: ctx.logger,
+      });
+      return true;
+    } catch (err) {
+      await emitWorkerEvent({
+        adapter,
+        binding,
+        agent: this.name,
+        sessionId,
+        cwd: projectDir,
+        replyToMessageId: inbound.messageId || null,
+        event: {
+          hook_event_name: 'worker.turn.error',
+          worker_event_name: 'worker.turn.error',
+          error: err?.message || 'Claude Code failed',
+        },
+        logger: ctx.logger,
+      });
+      await reportSubprocessFailure({
+        adapter,
+        binding,
+        inbound,
+        runtimeName: 'Claude Code',
+        info: err?.info || {
+          ok: false,
+          kind: 'exit-error',
+          errorMessage: err?.message || 'Claude Code failed',
+          durationMs: 0,
+        },
+      });
+      return terminalRuntimeFailure(err?.message || 'Claude Code failed');
+    }
+  },
+
+  async reconcileAfterRestart(binding, ctx) {
+    const meta = binding.runtimeMeta || {};
+    await emitWorkerEvent({
+      adapter: ctx.adapter,
+      binding,
+      agent: this.name,
+      sessionId: meta.sessionId || binding.id,
+      cwd: meta.projectDir || '',
+      event: {
+        hook_event_name: 'Stop',
+        worker_event_name: 'worker.turn.complete',
+        reason: 'connector.restart.reconcile',
+      },
+      logger: ctx.logger,
+    });
+    return 1;
+  },
+
+  // Friendly display name for a CC session (encoded project path →
+  // last meaningful segment). Used when materializing a binding.
+  formatDisplayName(session) {
+    return prettyProjectName(session.project || '');
+  },
+
+  // Compute the canonical transcript path for a (projectDir, sessionId)
+  // pair.
+  getTranscriptPath: getClaudeTranscriptPath,
+
+  // Adapter scan helper: friendly name from an encoded project string.
+  prettyProjectName,
+
+  // Paths + thresholds the adapter needs to discover sessions and
+  // bound sync ranges.
+  projectsDir: CC_PROJECTS_DIR,
+  maxAgeMs: CC_MAX_AGE_MS,
+};
+
+export default claudeCodeRuntime;