codelark 0.1.0

package/scripts/run-tests.js

@@ -0,0 +1,83 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'codelark-test-'));
+const runtimeHome = path.join(tempHome, 'runtime-home');
+const codexHome = path.join(tempHome, 'codex-home');
+const claudeHome = path.join(tempHome, 'claude-home');
+fs.mkdirSync(runtimeHome, { recursive: true });
+fs.mkdirSync(codexHome, { recursive: true });
+fs.mkdirSync(claudeHome, { recursive: true });
+
+const testsDir = path.join(process.cwd(), 'src', '__tests__');
+
+function discoverTestFiles(dir) {
+  return fs.readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      return discoverTestFiles(fullPath);
+    }
+    if (!entry.isFile() || !entry.name.endsWith('.test.ts')) {
+      return [];
+    }
+    return [path.relative(process.cwd(), fullPath)];
+  });
+}
+
+const layerFilters = new Map([
+  ['--unit', path.join('src', '__tests__', 'unit') + path.sep],
+  ['--workflow', path.join('src', '__tests__', 'workflow') + path.sep],
+  ['--mock-e2e', path.join('src', '__tests__', 'e2e', 'mock-app') + path.sep],
+  ['--local-e2e', path.join('src', '__tests__', 'e2e', 'local-process') + path.sep],
+  ['--harness', path.join('src', '__tests__', 'harness') + path.sep],
+]);
+
+const requestedLayers = process.argv.slice(2).filter((arg) => layerFilters.has(arg));
+const testFiles = discoverTestFiles(testsDir)
+  .sort()
+  .filter((file) => requestedLayers.length === 0 || requestedLayers.some((arg) => file.startsWith(layerFilters.get(arg))));
+
+if (testFiles.length === 0) {
+  console.error(`No test files matched ${requestedLayers.join(', ') || 'the current test discovery pattern'}.`);
+  process.exit(1);
+}
+
+const child = spawn(
+  process.execPath,
+  [
+    '--test',
+    '--test-concurrency=1',
+    '--import',
+    'tsx',
+    '--test-timeout=15000',
+    ...testFiles,
+  ],
+  {
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      HOME: runtimeHome,
+      USERPROFILE: runtimeHome,
+      CODELARK_HOME: tempHome,
+      CODEX_HOME: codexHome,
+      CODELARK_CLAUDE_HOME: claudeHome,
+    },
+  },
+);
+
+child.on('exit', (code, signal) => {
+  try {
+    fs.rmSync(tempHome, { recursive: true, force: true });
+  } catch {
+    // ignore
+  }
+
+  if (signal) {
+    process.kill(process.pid, signal);
+    return;
+  }
+
+  process.exit(code ?? 1);
+});

package/scripts/setup-wizard-real-e2e.ts

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+type FeishuSite = 'feishu' | 'lark';
+
+function valueArg(args: string[], name: string, fallback = ''): string {
+  const index = args.indexOf(name);
+  if (index < 0) return fallback;
+  return args[index + 1] || fallback;
+}
+
+function hasFlag(args: string[], name: string): boolean {
+  return args.includes(name);
+}
+
+function printUsage(): void {
+  process.stdout.write([
+    'Usage:',
+    '  CODELARK_SETUP_WIZARD_REAL_E2E=1 npm run real:setup-wizard:e2e -- [options]',
+    '',
+    'Options:',
+    '  --run-root <path>       Temporary root; default /tmp/clk-setup-wizard-real-e2e-<timestamp>',
+    '  --test-env-file <path>  Load test app credentials from an env file; avoids npm argument echo',
+    '  --app-id <cli_...>      App ID written to isolated lark-cli/CodeLark config',
+    '  --app-secret <secret>   App Secret for the isolated smoke app; prefer env file/env vars to avoid npm echo',
+    '  --site <feishu|lark>    Site brand; default feishu',
+    '  --keep-temp             Keep temporary root for diagnosis; default cleans it in success and failure paths',
+    '  --simulate-failure-after-sync  Test cleanup on a post-lark-cli failure',
+    '  --help                  Show this help',
+    '',
+  ].join('\n'));
+}
+
+function parseEnvFile(filePath: string): Record<string, string> {
+  if (!filePath) return {};
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const values: Record<string, string> = {};
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+    const separator = line.indexOf('=');
+    if (separator <= 0) continue;
+    const key = line.slice(0, separator).trim();
+    let value = line.slice(separator + 1).trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"'))
+      || (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    values[key] = value;
+  }
+  return values;
+}
+
+function envValue(envFile: Record<string, string>, key: string, legacyKey?: string): string {
+  return process.env[key] || envFile[key] || (legacyKey ? process.env[legacyKey] || envFile[legacyKey] || '' : '');
+}
+
+function assertInside(parentPath: string, childPath: string): void {
+  const parent = path.resolve(parentPath);
+  const child = path.resolve(childPath);
+  const relative = path.relative(parent, child);
+  if (relative === '' || (relative && !relative.startsWith('..') && !path.isAbsolute(relative))) return;
+  throw new Error(`Path escaped temp root: ${child}`);
+}
+
+async function main(): Promise<void> {
+  const argv = process.argv.slice(2);
+  if (hasFlag(argv, '--help')) {
+    printUsage();
+    return;
+  }
+  if (process.env.CODELARK_SETUP_WIZARD_REAL_E2E !== '1') {
+    throw new Error('Refusing to run setup wizard real e2e without CODELARK_SETUP_WIZARD_REAL_E2E=1.');
+  }
+  const testEnvFile = valueArg(argv, '--test-env-file', '');
+  const envFile = parseEnvFile(testEnvFile);
+
+  const runRoot = path.resolve(valueArg(
+    argv,
+    '--run-root',
+    path.join(os.tmpdir(), `clk-setup-wizard-real-e2e-${Date.now()}`),
+  ));
+  const keepTemp = hasFlag(argv, '--keep-temp');
+  const appId = valueArg(
+    argv,
+    '--app-id',
+    envValue(envFile, 'CODELARK_REAL_FEISHU_TEST_APP_ID', 'CTI_REAL_FEISHU_TEST_APP_ID') || 'cli_setup_wizard_real_e2e',
+  );
+  const appSecret = valueArg(
+    argv,
+    '--app-secret',
+    envValue(envFile, 'CODELARK_REAL_FEISHU_TEST_APP_SECRET', 'CTI_REAL_FEISHU_TEST_APP_SECRET') || 'setup-wizard-real-e2e-secret',
+  );
+  const siteArg = valueArg(
+    argv,
+    '--site',
+    envValue(envFile, 'CODELARK_REAL_FEISHU_TEST_SITE', 'CTI_REAL_FEISHU_TEST_SITE') || 'feishu',
+  );
+  const site: FeishuSite = siteArg === 'lark' ? 'lark' : 'feishu';
+
+  const runtimeHome = path.join(runRoot, 'home');
+  const codelarkHome = path.join(runRoot, 'clk-home');
+  const workspaceRoot = path.join(runRoot, 'workspace');
+  const larkConfigPath = path.join(runtimeHome, '.lark-cli', 'config.json');
+  const configEnvPath = path.join(codelarkHome, 'config.env');
+  const configJsonPath = path.join(codelarkHome, 'config.json');
+
+  try {
+    assertInside(os.tmpdir(), runRoot);
+    fs.mkdirSync(runtimeHome, { recursive: true });
+    fs.mkdirSync(codelarkHome, { recursive: true });
+    fs.mkdirSync(workspaceRoot, { recursive: true });
+    fs.writeFileSync(configEnvPath, '# custom env survives setup\nCUSTOM_KEEP=1\n', { mode: 0o600 });
+
+    process.env.HOME = runtimeHome;
+    process.env.USERPROFILE = runtimeHome;
+    process.env.CODELARK_HOME = codelarkHome;
+
+    const configuration = await import('../src/configuration/index.js');
+    const setupWizard = await import('../src/entrypoints/setup-wizard.js');
+
+    const credentials = {
+      appId,
+      appSecret,
+      site,
+      alias: 'codelark',
+    };
+
+    await setupWizard.syncLarkCliCredentials(credentials, runtimeHome);
+    const entriesAfterSync = setupWizard.readLarkCliAppEntries(larkConfigPath);
+    const syncedEntry = entriesAfterSync.find((entry) => entry.appId === appId);
+    if (!syncedEntry) throw new Error(`lark-cli config missing synced app ${appId}`);
+    if (syncedEntry.brand !== site) throw new Error(`lark-cli brand mismatch: ${syncedEntry.brand}`);
+    if (syncedEntry.appSecret) {
+      throw new Error('real lark-cli e2e expected lark-cli to avoid plaintext appSecret in this environment');
+    }
+    if (syncedEntry.secretStorage !== 'keychain') {
+      throw new Error(`expected keychain/local encrypted lark-cli secret storage, got ${syncedEntry.secretStorage}`);
+    }
+    const importableApps = setupWizard.readLarkCliApps(larkConfigPath);
+    const importableApp = importableApps.find((entry) => entry.appId === appId);
+    if (!importableApp) throw new Error(`CodeLark could not import synced lark-cli app ${appId}`);
+    if (importableApp.appSecret !== appSecret) {
+      throw new Error('CodeLark did not recover App Secret from lark-cli local encrypted storage');
+    }
+    if (hasFlag(argv, '--simulate-failure-after-sync')) {
+      throw new Error('simulated setup wizard real e2e failure after lark-cli sync');
+    }
+
+    const current = configuration.loadConfig();
+    configuration.saveConfig(setupWizard.buildSetupConfig(current, credentials, 'codex', workspaceRoot));
+
+    const savedConfig = configuration.loadConfig();
+    const savedFeishu = savedConfig.channels?.find((channel) => channel.provider === 'feishu');
+    if (savedConfig.runtime !== 'codex') throw new Error(`runtime mismatch: ${savedConfig.runtime}`);
+    if (savedConfig.defaultWorkspaceRoot !== workspaceRoot) {
+      throw new Error(`workspace mismatch: ${savedConfig.defaultWorkspaceRoot}`);
+    }
+    if (savedFeishu?.config.appId !== appId) throw new Error('config.v1 appId mismatch');
+    if (savedFeishu?.config.appSecret !== appSecret) throw new Error('config.v1 appSecret mismatch');
+    if (savedFeishu?.config.site !== site) throw new Error('config.v1 site mismatch');
+
+    const envContent = fs.readFileSync(configEnvPath, 'utf-8');
+    if (!envContent.includes('CUSTOM_KEEP=1')) throw new Error('custom config.env line was not preserved');
+    if (!envContent.includes(`CODELARK_FEISHU_APP_ID=${appId}`)) throw new Error('config.env appId missing');
+    if (!envContent.includes(`CODELARK_FEISHU_APP_SECRET=${appSecret}`)) throw new Error('config.env appSecret missing');
+    if (!fs.existsSync(configJsonPath)) throw new Error('config.json missing');
+
+    const result = {
+      ok: true,
+      runRoot,
+      runtimeHome,
+      codelarkHome,
+      larkConfigPath,
+      configEnvPath,
+      configJsonPath,
+      larkSecretStorage: syncedEntry.secretStorage,
+      cleanedRunRoot: !keepTemp,
+    };
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  } finally {
+    if (!keepTemp) {
+      fs.rmSync(runRoot, { recursive: true, force: true });
+    }
+  }
+}
+
+main().catch((error) => {
+  process.stderr.write(`${error instanceof Error ? error.stack || error.message : String(error)}\n`);
+  process.exit(1);
+});

package/scripts/supervisor-linux.sh

@@ -0,0 +1,49 @@
+#!/usr/bin/env bash
+# Linux supervisor — setsid/nohup fallback process management.
+# Sourced by daemon.sh; expects CODELARK_HOME, SKILL_DIR, PID_FILE, STATUS_FILE, LOG_FILE.
+
+# ── Public interface (called by daemon.sh) ──
+
+supervisor_start() {
+  if command -v setsid >/dev/null 2>&1; then
+    setsid node "$SKILL_DIR/dist/daemon.mjs" >> "$LOG_FILE" 2>&1 < /dev/null &
+  else
+    nohup node "$SKILL_DIR/dist/daemon.mjs" >> "$LOG_FILE" 2>&1 < /dev/null &
+  fi
+  # Fallback: write shell $! as PID; main.ts will overwrite with real PID
+  echo $! > "$PID_FILE"
+}
+
+supervisor_stop() {
+  local pid
+  pid=$(read_pid)
+  if [ -z "$pid" ]; then echo "No bridge running"; return 0; fi
+  if pid_alive "$pid"; then
+    kill "$pid"
+    for _ in $(seq 1 10); do
+      pid_alive "$pid" || break
+      sleep 1
+    done
+    pid_alive "$pid" && kill -9 "$pid"
+    echo "Bridge stopped"
+  else
+    echo "Bridge was not running (stale PID file)"
+  fi
+  rm -f "$PID_FILE"
+}
+
+supervisor_is_managed() {
+  # Linux fallback has no service manager; always false
+  return 1
+}
+
+supervisor_status_extra() {
+  # No extra status for Linux fallback
+  :
+}
+
+supervisor_is_running() {
+  local pid
+  pid=$(read_pid)
+  pid_alive "$pid"
+}

package/scripts/supervisor-macos.sh

@@ -0,0 +1,167 @@
+#!/usr/bin/env bash
+# macOS supervisor — launchd-based process management.
+# Sourced by daemon.sh; expects CODELARK_HOME, SKILL_DIR, PID_FILE, STATUS_FILE, LOG_FILE.
+
+LAUNCHD_LABEL="com.codelark.bridge"
+PLIST_DIR="$HOME/Library/LaunchAgents"
+PLIST_FILE="$PLIST_DIR/$LAUNCHD_LABEL.plist"
+
+# ── launchd helpers ──
+
+launchd_target() {
+  local label="$1"
+  echo "gui/$(id -u)/$label"
+}
+
+launchd_bootout() {
+  local label="$1"
+  launchctl bootout "$(launchd_target "$label")" 2>/dev/null || true
+}
+
+launchd_print() {
+  local label="$1"
+  launchctl print "$(launchd_target "$label")" 2>/dev/null
+}
+
+launchd_active_label() {
+  if launchd_print "$LAUNCHD_LABEL" >/dev/null; then
+    echo "$LAUNCHD_LABEL"
+    return 0
+  fi
+  return 1
+}
+
+launchd_pid_for_label() {
+  local label="$1"
+  launchd_print "$label" | grep -m1 'pid = ' | sed 's/.*pid = //' | tr -d ' '
+}
+
+# Collect env vars that should be forwarded into the plist.
+# We honour clean_env() logic by reading *after* clean_env runs.
+build_env_dict() {
+  local indent="            "
+  local dict=""
+
+  # Always forward basics
+  for var in HOME PATH USER SHELL LANG TMPDIR; do
+    local val="${!var:-}"
+    [ -z "$val" ] && continue
+    dict+="${indent}<key>${var}</key>\n${indent}<string>${val}</string>\n"
+  done
+
+  # Forward CodeLark-specific vars.
+  while IFS='=' read -r name val; do
+    case "$name" in CODELARK_*)
+      dict+="${indent}<key>${name}</key>\n${indent}<string>${val}</string>\n"
+      ;; esac
+  done < <(env)
+
+  # Forward Codex/OpenAI credentials used by the Codex runtime.
+  for var in OPENAI_API_KEY CODEX_API_KEY CODELARK_CODEX_API_KEY CODELARK_CODEX_BASE_URL; do
+    local val="${!var:-}"
+    [ -z "$val" ] && continue
+    dict+="${indent}<key>${var}</key>\n${indent}<string>${val}</string>\n"
+  done
+
+  echo -e "$dict"
+}
+
+generate_plist() {
+  local node_path
+  node_path=$(command -v node)
+
+  mkdir -p "$PLIST_DIR"
+  local env_dict
+  env_dict=$(build_env_dict)
+
+  cat > "$PLIST_FILE" <<PLIST
+<?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>${LAUNCHD_LABEL}</string>
+
+    <key>ProgramArguments</key>
+    <array>
+        <string>${node_path}</string>
+        <string>${SKILL_DIR}/dist/daemon.mjs</string>
+    </array>
+
+    <key>WorkingDirectory</key>
+    <string>${SKILL_DIR}</string>
+
+    <key>StandardOutPath</key>
+    <string>${LOG_FILE}</string>
+    <key>StandardErrorPath</key>
+    <string>${LOG_FILE}</string>
+
+    <key>RunAtLoad</key>
+    <false/>
+
+    <key>KeepAlive</key>
+    <dict>
+        <key>SuccessfulExit</key>
+        <false/>
+    </dict>
+
+    <key>ThrottleInterval</key>
+    <integer>10</integer>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+${env_dict}    </dict>
+</dict>
+</plist>
+PLIST
+}
+
+# ── Public interface (called by daemon.sh) ──
+
+supervisor_start() {
+  launchd_bootout "$LAUNCHD_LABEL"
+  generate_plist
+  launchctl bootstrap "gui/$(id -u)" "$PLIST_FILE"
+  launchctl kickstart -k "$(launchd_target "$LAUNCHD_LABEL")"
+}
+
+supervisor_stop() {
+  launchd_bootout "$LAUNCHD_LABEL"
+  rm -f "$PID_FILE"
+}
+
+supervisor_is_managed() {
+  launchd_active_label >/dev/null
+}
+
+supervisor_status_extra() {
+  local active_label
+  active_label=$(launchd_active_label 2>/dev/null || true)
+  if [ -n "$active_label" ]; then
+    echo "Bridge is registered with launchd ($active_label)"
+    # Extract PID from launchctl as the authoritative source
+    local lc_pid
+    lc_pid=$(launchd_pid_for_label "$active_label")
+    if [ -n "$lc_pid" ] && [ "$lc_pid" != "0" ] && [ "$lc_pid" != "-" ]; then
+      echo "launchd reports PID: $lc_pid"
+    fi
+  fi
+}
+
+# Override: on macOS, check launchctl first, then fall back to PID file
+supervisor_is_running() {
+  # Primary: launchctl knows the process
+  local active_label
+  active_label=$(launchd_active_label 2>/dev/null || true)
+  if [ -n "$active_label" ]; then
+    local lc_pid
+    lc_pid=$(launchd_pid_for_label "$active_label")
+    if [ -n "$lc_pid" ] && [ "$lc_pid" != "0" ] && [ "$lc_pid" != "-" ]; then
+      return 0
+    fi
+  fi
+  # Fallback: PID file
+  local pid
+  pid=$(read_pid)
+  pid_alive "$pid"
+}