agentlas 0.9.10 → 1.0.2

package/engine/automation/store.cjs

@@ -0,0 +1,209 @@
+"use strict";
+/*
+ * automation/store — automations 테이블 DB 표면 (목록/추가/토글/삭제 + 리스 + 실행 기록).
+ *
+ * 스키마 소유권: 정본은 데스크탑 앱. 이 모듈은 base 열(id, name, schedule,
+ * target_type, target_id, prompt_template, enabled, created_at, next_run_at,
+ * last_run_at)만 전제하고, 그 뒤에 추가된 열(timezone, trigger_type, tool_mode,
+ * hub_mode, run_count, claimed_at, lease_owner, …)은 columnExists 로 방어한다.
+ *
+ * 리스 계약(절대 약화 금지): claimed_at TTL 15분 — 앱 store/automations.ts 의
+ * LEASE_TTL_MS 와 동일. Desktop 스케줄러와 터미널 데몬이 같은 SQLite 를 보므로,
+ * 리스를 잡지 못한 쪽은 절대 실행하지 않는다(중복 실행 = codex 자동화 전멸급 사고).
+ * 리스 열이 없는 구형 DB에서는 배타성을 증명할 수 없으므로 fail-closed(실행 거부).
+ */
+const crypto = require("node:crypto");
+const os = require("node:os");
+const { columnExists, tableExists } = require("../core/db.cjs");
+const { nextAutomationRun } = require("./schedule.cjs");
+
+const LEASE_TTL_MS = 15 * 60 * 1000; // 앱 store/automations.ts LEASE_TTL_MS와 동일
+const LEASE_OWNER = `cli:${os.hostname()}:${process.pid}`;
+
+function leaseSupported(db) {
+  return columnExists(db, "automations", "claimed_at") && columnExists(db, "automations", "lease_owner");
+}
+
+function listAutomations(db) {
+  if (!tableExists(db, "automations")) return [];
+  return db.prepare("SELECT * FROM automations ORDER BY created_at DESC").all();
+}
+
+function getAutomationByPrefix(db, idPrefix) {
+  if (!tableExists(db, "automations")) return null;
+  return db.prepare("SELECT * FROM automations WHERE id LIKE ?").get(String(idPrefix) + "%") || null;
+}
+
+/**
+ * 자동화 추가. spec: { name, targetType, targetId, cron, prompt, tz?, disabled? }
+ * next_run_at 은 호출자가 검증한 nextCronRun 결과(Date)를 받는다.
+ * @returns {string} 새 automation id
+ */
+function addAutomation(db, spec, next) {
+  const id = crypto.randomUUID();
+  const now = new Date().toISOString();
+  const cols = ["id", "name", "schedule", "target_type", "target_id", "prompt_template", "enabled", "created_at", "next_run_at"];
+  const vals = [
+    id,
+    spec.name,
+    spec.cron,
+    spec.targetType,
+    spec.targetId,
+    spec.prompt,
+    spec.disabled ? 0 : 1,
+    now,
+    next ? next.toISOString() : null,
+  ];
+  // 데스크탑이 나중에 추가한 열 — 있으면 v1과 동일한 값으로 채운다.
+  const optional = {
+    created_by: "cli",
+    timezone: spec.tz || null,
+    trigger_type: "schedule",
+    tool_mode: "auto",
+    hub_mode: "hub-allowed",
+    run_count: 0,
+  };
+  for (const [col, v] of Object.entries(optional)) {
+    if (columnExists(db, "automations", col)) {
+      cols.push(col);
+      vals.push(v);
+    }
+  }
+  db.prepare(`INSERT INTO automations (${cols.join(",")}) VALUES (${cols.map(() => "?").join(",")})`).run(...vals);
+  return id;
+}
+
+/** on: next_run_at 재계산 후 활성화. off: 비활성화(스케줄 보존). */
+function setEnabled(db, row, enabled) {
+  if (enabled) {
+    const next = nextAutomationRun(row) || null;
+    db.prepare("UPDATE automations SET enabled=1, next_run_at=? WHERE id=?").run(next ? next.toISOString() : null, row.id);
+    return next;
+  }
+  db.prepare("UPDATE automations SET enabled=0 WHERE id=?").run(row.id);
+  return null;
+}
+
+function removeAutomation(db, id) {
+  db.prepare("DELETE FROM automations WHERE id=?").run(id);
+}
+
+/**
+ * 리스 획득 — 앱 스케줄러와 같은 SQLite 리스(claimed_at TTL 15분)로 중복 실행 방지.
+ * 원자적 조건부 UPDATE 하나로 판정한다(SELECT 후 UPDATE 금지 — 레이스).
+ * @returns {boolean} true = 이 프로세스가 배타 실행권을 가짐
+ */
+function claimAutomation(db, id, now = new Date(), owner = LEASE_OWNER) {
+  // 리스 열이 없으면 배타성을 증명할 수 없다 — 중복 실행 위험을 감수하지 않고 거부.
+  if (!leaseSupported(db)) return false;
+  const cutoff = new Date(now.getTime() - LEASE_TTL_MS).toISOString();
+  const result = db
+    .prepare(
+      "UPDATE automations SET claimed_at = ?, lease_owner = ? WHERE id = ? AND enabled = 1 AND (claimed_at IS NULL OR claimed_at < ?)",
+    )
+    .run(now.toISOString(), owner, id, cutoff);
+  return (result.changes ?? result.rowsAffected ?? 0) > 0;
+}
+
+function releaseAutomation(db, id) {
+  try {
+    db.prepare("UPDATE automations SET claimed_at = NULL, lease_owner = NULL WHERE id = ?").run(id);
+  } catch { /* best-effort */ }
+}
+
+/**
+ * 실행 기록 — run_history(v1/Desktop 스케줄러 패리티) + automation_runs(있으면) 양쪽.
+ * best-effort: 기록 실패가 자동화 실행 자체를 죽이면 안 된다.
+ */
+function recordRun(db, automationId, status, error, scheduledFor) {
+  const nowIso = new Date().toISOString();
+  try {
+    if (tableExists(db, "run_history")) {
+      db.prepare(
+        "INSERT INTO run_history (id, automation_id, scheduled_for, ran_at, status, skipped_count, error) VALUES (?,?,?,?,?,0,?)",
+      ).run(crypto.randomUUID(), automationId, scheduledFor || null, nowIso, status, error || null);
+    }
+  } catch { /* best-effort */ }
+  try {
+    if (tableExists(db, "automation_runs")) {
+      db.prepare(
+        "INSERT INTO automation_runs (id, automation_id, started_at, status, node_states_json) VALUES (?,?,?,?,NULL)",
+      ).run(crypto.randomUUID(), automationId, nowIso, status);
+    }
+  } catch { /* best-effort */ }
+}
+
+function listRuns(db, limit = 15) {
+  if (!tableExists(db, "run_history")) return [];
+  return db.prepare(
+    `SELECT h.ran_at, h.status, h.error, a.name FROM run_history h
+       LEFT JOIN automations a ON a.id = h.automation_id
+       ORDER BY h.ran_at DESC LIMIT ?`,
+  ).all(Math.max(1, limit));
+}
+
+/**
+ * 실행 후 스케줄 북키핑 — v1 runAutomationOnce 의 성공/실패 분기와 동일:
+ *  - 성공: run_count 증가. 실패: last_run_at 만 갱신(성공 카운트 오염 금지).
+ *  - advanceSchedule(데몬 경로)일 때만 next_run_at 전진; 다음 시각이 없으면 비활성화.
+ *  - run-now(advanceSchedule=false)는 스케줄을 건드리지 않는다(앱 advanceSchedule=false와 동일).
+ */
+function advanceAfterRun(db, row, { ok, advanceSchedule, ranAt = new Date() } = {}) {
+  const hasRunCount = columnExists(db, "automations", "run_count");
+  const shouldAdvance = !!advanceSchedule && (row.trigger_type || "schedule") === "schedule";
+  const advance = shouldAdvance ? nextAutomationRun(row, ranAt) : null;
+  if (ok) {
+    if (shouldAdvance) {
+      if (hasRunCount) {
+        db.prepare(
+          "UPDATE automations SET last_run_at = ?, run_count = run_count + 1, next_run_at = ?, enabled = ? WHERE id = ?",
+        ).run(ranAt.toISOString(), advance ? advance.toISOString() : null, advance ? row.enabled : 0, row.id);
+      } else {
+        db.prepare("UPDATE automations SET last_run_at = ?, next_run_at = ?, enabled = ? WHERE id = ?")
+          .run(ranAt.toISOString(), advance ? advance.toISOString() : null, advance ? row.enabled : 0, row.id);
+      }
+    } else if (hasRunCount) {
+      db.prepare("UPDATE automations SET last_run_at = ?, run_count = run_count + 1 WHERE id = ?")
+        .run(ranAt.toISOString(), row.id);
+    } else {
+      db.prepare("UPDATE automations SET last_run_at = ? WHERE id = ?").run(ranAt.toISOString(), row.id);
+    }
+    // max_runs 도달 시 비활성화 (앱과 동일한 종료 조건).
+    if (row.max_runs && (row.run_count || 0) + 1 >= row.max_runs) {
+      db.prepare("UPDATE automations SET enabled = 0 WHERE id = ?").run(row.id);
+      return { advance, maxRunsReached: true };
+    }
+  } else if (shouldAdvance) {
+    db.prepare("UPDATE automations SET last_run_at = ?, next_run_at = ?, enabled = ? WHERE id = ?")
+      .run(ranAt.toISOString(), advance ? advance.toISOString() : null, advance ? row.enabled : 0, row.id);
+  } else {
+    db.prepare("UPDATE automations SET last_run_at = ? WHERE id = ?").run(ranAt.toISOString(), row.id);
+  }
+  return { advance, maxRunsReached: false };
+}
+
+/** 데몬 폴링: 활성 + 스케줄 트리거 + next_run_at 도래분. trigger_type 열은 방어적. */
+function dueAutomations(db, nowIso = new Date().toISOString(), limit = 5) {
+  if (!tableExists(db, "automations")) return [];
+  const triggerFilter = columnExists(db, "automations", "trigger_type") ? "AND trigger_type = 'schedule'" : "";
+  return db.prepare(
+    `SELECT * FROM automations WHERE enabled = 1 ${triggerFilter} AND next_run_at IS NOT NULL AND next_run_at <= ? ORDER BY next_run_at ASC LIMIT ?`,
+  ).all(nowIso, limit);
+}
+
+module.exports = {
+  LEASE_TTL_MS,
+  LEASE_OWNER,
+  leaseSupported,
+  listAutomations,
+  getAutomationByPrefix,
+  addAutomation,
+  setEnabled,
+  removeAutomation,
+  claimAutomation,
+  releaseAutomation,
+  recordRun,
+  listRuns,
+  advanceAfterRun,
+  dueAutomations,
+};

package/engine/cloud/auth.cjs

@@ -0,0 +1,279 @@
+"use strict";
+/*
+ * cloud/auth — Agentlas Cloud 로그인 세션. 단일 관심사:
+ *   loopback OAuth 로그인 플로우 + CLI 세션 영속화 + whoami 조회.
+ *
+ * 보안 계약 (test/login-loopback-security.cjs 가 전부 검증한다 — 바꾸면 테스트부터):
+ *  - state 는 32바이트 crypto 난수(base64url, 43자). 비교는 timingSafeEqual.
+ *  - `/callback` GET 1회로 transaction 소비 — 성공/실패 무관. 잘못된 state 뒤에
+ *    공격자 세션을 재주입하거나 성공 URL 재생으로 세션을 덮어쓸 수 없다.
+ *  - 서버는 127.0.0.1 임시 포트만 listen, GET 외 405, 무관 경로 404(미소비),
+ *    모든 응답에 no-store + 'none' CSP + nosniff.
+ *  - OAuth error 코드는 화이트리스트 정규식 통과분만 에러 메시지에 반영(반사 방지).
+ *
+ * 세션 파일은 평문·0600 (`<userData>/auth/cli-session.v1.json`) — 데스크탑의
+ * safeStorage 파일과 별개다. 쿠키 해석 순서: AGENTLAS_SESSION env → 세션 파일.
+ */
+const fs = require("node:fs");
+const path = require("node:path");
+const crypto = require("node:crypto");
+const { spawn } = require("node:child_process");
+const { userDataDir } = require("../core/paths.cjs");
+
+const LOGIN_CALLBACK_PATH = "/callback";
+const LOGIN_TIMEOUT_MS = 180_000;
+const MAX_LOGIN_SESSION_BYTES = 16 * 1024;
+
+function webBaseUrl() {
+  return (process.env.AGENTLAS_WEB_BASE_URL || "https://agentlas.cloud").replace(/\/$/, "");
+}
+
+function createLoginState(randomBytes = crypto.randomBytes) {
+  const bytes = Buffer.from(randomBytes(32));
+  if (bytes.length !== 32) throw new Error("Could not create the login state.");
+  return bytes.toString("base64url");
+}
+
+function loginStatesMatch(actual, expected) {
+  const left = Buffer.from(String(actual || ""), "utf8");
+  const right = Buffer.from(String(expected || ""), "utf8");
+  return left.length === right.length && left.length > 0 && crypto.timingSafeEqual(left, right);
+}
+
+/**
+ * OAuth loopback callback의 1회용 state guard. `/callback` GET이 도착하면 성공/실패와
+ * 무관하게 transaction을 소비한다. 따라서 잘못된 state 뒤에 공격자 세션을 재주입하거나,
+ * 성공 URL을 재생해 다른 세션으로 덮어쓸 수 없다.
+ */
+function createLoginCallbackGuard(expectedState) {
+  let consumed = false;
+  return {
+    consume(rawUrl, method = "GET") {
+      let url;
+      try {
+        url = new URL(String(rawUrl || "/"), "http://127.0.0.1");
+      } catch {
+        return { handled: true, final: false, ok: false, statusCode: 400, message: "Invalid login callback." };
+      }
+      if (url.pathname !== LOGIN_CALLBACK_PATH) {
+        return { handled: false, final: false, ok: false, statusCode: 404, message: "not found" };
+      }
+      if (method !== "GET") {
+        return { handled: true, final: false, ok: false, statusCode: 405, message: "method not allowed" };
+      }
+      if (consumed) {
+        return { handled: true, final: false, ok: false, statusCode: 410, message: "Login callback has already been used." };
+      }
+      consumed = true;
+
+      if (!loginStatesMatch(url.searchParams.get("state"), expectedState)) {
+        return {
+          handled: true,
+          final: true,
+          ok: false,
+          statusCode: 400,
+          message: "Login callback state validation failed. Run agentlas login again.",
+        };
+      }
+      const oauthError = url.searchParams.get("error");
+      if (oauthError) {
+        // 에러 코드는 화이트리스트 통과분만 반영 — error_description 등 자유 텍스트는 절대 반사하지 않는다.
+        const safeCode = /^[A-Za-z0-9_.-]{1,80}$/.test(oauthError) ? oauthError : "oauth_error";
+        return {
+          handled: true,
+          final: true,
+          ok: false,
+          statusCode: 400,
+          message: `Agentlas login denied: ${safeCode}`,
+        };
+      }
+      const value = url.searchParams.get("session") || url.searchParams.get("token") || "";
+      if (!value) {
+        return {
+          handled: true,
+          final: true,
+          ok: false,
+          statusCode: 400,
+          message: "The callback did not include a session value.",
+        };
+      }
+      if (Buffer.byteLength(value, "utf8") > MAX_LOGIN_SESSION_BYTES) {
+        return {
+          handled: true,
+          final: true,
+          ok: false,
+          statusCode: 400,
+          message: "The login session value is too large.",
+        };
+      }
+      return { handled: true, final: true, ok: true, statusCode: 200, value, message: "Agentlas login complete" };
+    },
+    isConsumed() { return consumed; },
+  };
+}
+
+// URL 출력은 이미 호출자가 했다는 전제 — 브라우저를 못 열어도 조용히 넘어간다(수동으로 열면 된다).
+function openInBrowser(url) {
+  const argv =
+    process.platform === "darwin" ? ["open", url]
+    : process.platform === "win32" ? ["cmd", "/c", "start", "", url]
+    : ["xdg-open", url];
+  try {
+    const child = spawn(argv[0], argv.slice(1), { stdio: "ignore", detached: true });
+    child.unref();
+  } catch { /* ignore */ }
+}
+
+function loginCallbackHtml(ok) {
+  const title = ok ? "Agentlas login complete" : "Agentlas login failed";
+  const body = ok
+    ? "Return to the terminal. You can close this window."
+    : "Return to the terminal and run agentlas login again.";
+  return `<!doctype html><html><head><meta charset="utf-8"><title>Agentlas</title></head><body style="font-family:-apple-system,system-ui,sans-serif;padding:40px"><h3>${title}</h3><p>${body}</p></body></html>`;
+}
+
+/**
+ * 127.0.0.1 임시 포트에 1회용 loopback 서버를 열고, 웹 `/account?desktop=1&callback=…`
+ * 로그인 흐름이 state 를 보존한 채 세션을 되돌려줄 때까지 기다린다.
+ * options: { baseUrl?, timeoutMs?, onLoginUrl?, http?, randomBytes? }
+ */
+function waitForLoopbackSession(options = {}) {
+  const http = options.http || require("node:http");
+  const timeoutCandidate = Number(options.timeoutMs);
+  const timeoutMs = Number.isFinite(timeoutCandidate) && timeoutCandidate > 0 ? timeoutCandidate : LOGIN_TIMEOUT_MS;
+  const state = createLoginState(options.randomBytes || crypto.randomBytes);
+  const guard = createLoginCallbackGuard(state);
+  const onLoginUrl = options.onLoginUrl || ((url) => {
+    process.stdout.write("Sign in to Agentlas in the browser (opening automatically):\n  " + url + "\n");
+    openInBrowser(url);
+  });
+
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timer = null;
+    let server;
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      try { if (server) server.close(); } catch { /* ignore */ }
+      if (error) reject(error);
+      else resolve(value);
+    };
+
+    server = http.createServer((req, res) => {
+      const result = guard.consume(req.url, req.method || "GET");
+      const headers = {
+        "content-type": result.handled ? "text/html; charset=utf-8" : "text/plain; charset=utf-8",
+        "cache-control": "no-store",
+        "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'",
+        "x-content-type-options": "nosniff",
+        connection: "close",
+      };
+      if (result.statusCode === 405) headers.allow = "GET";
+      res.writeHead(result.statusCode, headers);
+      res.end(result.handled ? loginCallbackHtml(result.ok) : result.message);
+      if (!result.final) return;
+      if (result.ok) finish(null, result.value);
+      else finish(new Error(result.message));
+    });
+    server.on("error", (error) => finish(error));
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      const port = address && typeof address === "object" ? address.port : 0;
+      if (!port) {
+        finish(new Error("Could not open the login loopback port."));
+        return;
+      }
+      const callback = new URL(`http://127.0.0.1:${port}${LOGIN_CALLBACK_PATH}`);
+      callback.searchParams.set("state", state);
+      let loginUrl;
+      try {
+        loginUrl = new URL("/account", `${options.baseUrl || webBaseUrl()}/`);
+      } catch {
+        finish(new Error("The Agentlas login URL is invalid."));
+        return;
+      }
+      loginUrl.searchParams.set("desktop", "1");
+      loginUrl.searchParams.set("callback", callback.toString());
+      timer = setTimeout(
+        () => finish(new Error(`Login timed out after ${Math.ceil(timeoutMs / 1000)} seconds. Try: agentlas login`)),
+        timeoutMs,
+      );
+      if (timer.unref) timer.unref();
+      try {
+        const notified = onLoginUrl(loginUrl.toString());
+        if (notified && typeof notified.then === "function") {
+          void notified.catch((error) => finish(error));
+        }
+      } catch (error) {
+        finish(error);
+      }
+    });
+  });
+}
+
+// ── CLI 세션 영속화 (v1 포맷 그대로: { version: 1, value, updatedAt }) ──
+function cliSessionPath() {
+  return path.join(userDataDir(), "auth", "cli-session.v1.json");
+}
+
+function readCliSessionValue() {
+  try {
+    const j = JSON.parse(fs.readFileSync(cliSessionPath(), "utf8"));
+    return (j && typeof j.value === "string" && j.value) || null;
+  } catch {
+    return null;
+  }
+}
+
+function saveCliSession(value) {
+  const p = cliSessionPath();
+  // 디렉터리 0700 + 파일 0600 — 기본 umask(0644)로 세션이 world-readable 이 되는 것을 막는다.
+  fs.mkdirSync(path.dirname(p), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(p, JSON.stringify({ version: 1, value, updatedAt: new Date().toISOString() }, null, 2) + "\n", { mode: 0o600 });
+  try { fs.chmodSync(p, 0o600); } catch { /* win32 */ }
+  return p;
+}
+
+function deleteCliSession() {
+  const p = cliSessionPath();
+  if (!fs.existsSync(p)) return { existed: false, path: p };
+  fs.rmSync(p);
+  return { existed: true, path: p };
+}
+
+// 쿠키 해석 순서 계약: AGENTLAS_SESSION env → 세션 파일. (v1의 keytar 폴백은
+// 데스크탑이 세션을 keytar에 두지 않아 항상 비어 있었다 — v2에서는 싣지 않는다.)
+function cloudSessionCookie() {
+  if (process.env.AGENTLAS_SESSION) return `agentlas_session=${process.env.AGENTLAS_SESSION}`;
+  const fileValue = readCliSessionValue();
+  if (fileValue) return `agentlas_session=${fileValue}`;
+  return null;
+}
+
+async function fetchSessionMeta(cookie) {
+  const resp = await fetch(`${webBaseUrl()}/api/auth/session`, { headers: { cookie }, signal: AbortSignal.timeout(8000) });
+  if (!resp.ok) throw new Error(`Session check returned ${resp.status}`);
+  return resp.json();
+}
+
+// 레거시 테스트 호환 표면 (v1 agentlas-parity.cjs 의 create(deps) 모양).
+// v2 명령은 위의 모듈 함수들을 직접 쓰고, 이 create 는 아무 deps 도 요구하지 않는다.
+function create() {
+  return { waitForLoopbackSession };
+}
+
+module.exports = {
+  create,
+  webBaseUrl,
+  openInBrowser,
+  waitForLoopbackSession,
+  cliSessionPath,
+  readCliSessionValue,
+  saveCliSession,
+  deleteCliSession,
+  cloudSessionCookie,
+  fetchSessionMeta,
+  _test: { createLoginState, createLoginCallbackGuard },
+};