loopable-cli 0.1.0

package/dist/runner.mjs

@@ -0,0 +1,657 @@
+// src/runner/client.ts
+import { closeSync, existsSync, fstatSync, mkdtempSync, openSync, readSync, rmSync as rmSync2 } from "node:fs";
+import { tmpdir } from "node:os";
+import { hostname as osHostname } from "node:os";
+import { join as join4 } from "node:path";
+
+// src/agents/define.ts
+function defineAgentManifest(manifest) {
+  return manifest;
+}
+function defineAgentRuntime(runtime) {
+  return runtime;
+}
+
+// src/agents/codex/manifest.ts
+var codexManifest = defineAgentManifest({
+  id: "codex",
+  name: "Codex",
+  tagline: "OpenAI's coding agent, driven non-interactively through codex exec.",
+  docsUrl: "https://developers.openai.com/codex/cli",
+  icon: "Terminal",
+  accent: "bg-neutral-900 text-white",
+  binaries: ["codex"],
+  installHint: "Install with npm i -g @openai/codex, then run codex login.",
+  permissionModes: ["read_only", "workspace_write"],
+  supportsModel: true,
+  modelPlaceholder: "leave empty for the Codex default",
+  defaults: { permissionMode: "read_only", model: null, timeoutMs: 3e5 }
+});
+
+// src/agents/cursor-agent/manifest.ts
+var cursorAgentManifest = defineAgentManifest({
+  id: "cursor-agent",
+  name: "Cursor Agent",
+  tagline: "Cursor's CLI agent, driven through its print mode.",
+  docsUrl: "https://cursor.com/docs/cli",
+  icon: "MousePointerClick",
+  accent: "bg-blue-600 text-white",
+  binaries: ["cursor-agent"],
+  installHint: "Install with curl https://cursor.com/install -fsS | bash, then run cursor-agent login.",
+  permissionModes: ["read_only", "workspace_write"],
+  supportsModel: true,
+  modelPlaceholder: "e.g. gpt-5 or sonnet-4.5",
+  defaults: { permissionMode: "read_only", model: null, timeoutMs: 3e5 }
+});
+
+// src/agents/manifests.ts
+var AGENT_MANIFESTS = [codexManifest, cursorAgentManifest];
+
+// src/agents/codex/runtime.ts
+import { readFileSync, rmSync } from "node:fs";
+
+// src/agents/discover.ts
+import { execFile } from "node:child_process";
+import { accessSync, constants } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+var exec = promisify(execFile);
+var HOME_DIRS = [".local/bin", ".bun/bin", ".cargo/bin", ".volta/bin", ".deno/bin"];
+var SYSTEM_DIRS = ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"];
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+function inheritedDirs() {
+  const home = homedir();
+  return unique([
+    ...(process.env.PATH ?? "").split(":"),
+    ...HOME_DIRS.map((dir) => join(home, dir)),
+    ...SYSTEM_DIRS
+  ]);
+}
+var loginDirs = null;
+async function loginShellDirs() {
+  if (loginDirs) return loginDirs;
+  try {
+    const shell = process.env.SHELL ?? "/bin/zsh";
+    const { stdout } = await exec(shell, ["-lc", 'printf %s "$PATH"'], { timeout: 5e3 });
+    loginDirs = unique(stdout.split(":"));
+  } catch {
+    loginDirs = [];
+  }
+  return loginDirs;
+}
+function executableIn(dirs, names) {
+  for (const dir of dirs) {
+    for (const name of names) {
+      const candidate = join(dir, name);
+      try {
+        accessSync(candidate, constants.X_OK);
+        return candidate;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+async function resolveBinary(names) {
+  return executableIn(inheritedDirs(), names) ?? executableIn(await loginShellDirs(), names);
+}
+var ANSI = /\u001B\[[0-9;]*[A-Za-z]/g;
+function clean(text) {
+  return text.replace(ANSI, "").trim();
+}
+async function probe(bin, args3, timeoutMs = 1e4) {
+  try {
+    const { stdout, stderr } = await exec(bin, args3, { timeout: timeoutMs });
+    return { ok: true, text: clean(stdout) || clean(stderr) };
+  } catch (error) {
+    const failure = error;
+    return {
+      ok: false,
+      text: clean(failure.stdout ?? "") || clean(failure.stderr ?? "") || (failure.message ?? "failed")
+    };
+  }
+}
+function firstLine(text) {
+  return clean(text).split("\n")[0]?.trim() ?? "";
+}
+
+// src/agents/process.ts
+import { spawn } from "node:child_process";
+import { createWriteStream } from "node:fs";
+var WITHHELD = [/^GITHUB_/, /^GH_/, /^LOOPABLE_/];
+function agentEnvironment() {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (WITHHELD.some((pattern) => pattern.test(key))) continue;
+    env[key] = value;
+  }
+  return env;
+}
+function signalGroup(pid, signal) {
+  if (pid === void 0) return;
+  try {
+    process.kill(-pid, signal);
+  } catch {
+    try {
+      process.kill(pid, signal);
+    } catch {
+    }
+  }
+}
+function runProcess(input) {
+  return new Promise((resolve) => {
+    const started = Date.now();
+    if (input.signal?.aborted) {
+      resolve({ code: null, stdout: "", stderr: "", timedOut: false, aborted: true, durationMs: 0 });
+      return;
+    }
+    const child = spawn(input.bin, input.args, {
+      cwd: input.cwd,
+      env: agentEnvironment(),
+      stdio: ["ignore", "pipe", "pipe"],
+      // Its own process group, so it can be stopped as a family. Agent CLIs
+      // start helpers of their own, and signalling only the process we
+      // launched leaves those behind, reparented to init and still working.
+      detached: true
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let aborted = false;
+    const halt = () => {
+      signalGroup(child.pid, "SIGTERM");
+      setTimeout(() => signalGroup(child.pid, "SIGKILL"), 3e3).unref();
+    };
+    const timer = setTimeout(() => {
+      timedOut = true;
+      halt();
+    }, input.timeoutMs);
+    const onAbort = () => {
+      aborted = true;
+      halt();
+    };
+    input.signal?.addEventListener("abort", onAbort);
+    const logFile = input.logPath ? createWriteStream(input.logPath, { flags: "a" }) : null;
+    logFile?.on("error", () => {
+    });
+    const lineWriter = () => {
+      let pending = "";
+      const emit = (line) => {
+        const text = input.logLine ? input.logLine(line) : line;
+        if (text !== null && text !== "") logFile?.write(`${text}
+`);
+      };
+      return {
+        take(chunk) {
+          if (!logFile) return;
+          pending += chunk;
+          const lines = pending.split("\n");
+          pending = lines.pop() ?? "";
+          for (const line of lines) emit(line);
+        },
+        flush() {
+          if (logFile && pending !== "") emit(pending);
+          pending = "";
+        }
+      };
+    };
+    const outLines = lineWriter();
+    const errLines = lineWriter();
+    child.stdout.on("data", (chunk) => {
+      const text = chunk.toString();
+      stdout += text;
+      outLines.take(text);
+    });
+    child.stderr.on("data", (chunk) => {
+      const text = chunk.toString();
+      stderr += text;
+      errLines.take(text);
+    });
+    const finish = (code, failure) => {
+      clearTimeout(timer);
+      input.signal?.removeEventListener("abort", onAbort);
+      outLines.flush();
+      errLines.flush();
+      if (failure) logFile?.write(`
+${failure}
+`);
+      logFile?.end();
+      resolve({
+        code,
+        stdout: clean(stdout),
+        stderr: clean(failure ? `${stderr}
+${failure}` : stderr),
+        timedOut,
+        aborted,
+        durationMs: Date.now() - started
+      });
+    };
+    child.on("error", (error) => finish(null, error.message));
+    child.on("close", (code) => finish(code));
+  });
+}
+
+// src/agents/codex/runtime.ts
+async function binary() {
+  const found = await resolveBinary(codexManifest.binaries);
+  if (!found) throw new Error("The codex binary was not found on this host.");
+  return found;
+}
+function args(input) {
+  const list = [
+    "exec",
+    "--sandbox",
+    input.settings.permissionMode === "read_only" ? "read-only" : "workspace-write",
+    // The workspace is a scratch directory rather than a checkout, and session
+    // files would outlive a run that is meant to leave nothing behind.
+    "--skip-git-repo-check",
+    "--ephemeral",
+    "--color",
+    "never",
+    "-C",
+    input.cwd
+  ];
+  if (input.settings.model) list.push("-m", input.settings.model);
+  if (input.outputFile) list.push("-o", input.outputFile);
+  list.push(input.prompt);
+  return list;
+}
+var codexRuntime = defineAgentRuntime({
+  async detect() {
+    const found = await resolveBinary(codexManifest.binaries);
+    if (!found) return { installed: false };
+    const version = await probe(found, ["--version"]);
+    return { installed: true, binaryPath: found, version: firstLine(version.text) };
+  },
+  async authStatus() {
+    const found = await resolveBinary(codexManifest.binaries);
+    if (!found) return { signedIn: false, detail: "Not installed." };
+    const result = await probe(found, ["login", "status"]);
+    return {
+      signedIn: result.ok,
+      detail: firstLine(result.text) || (result.ok ? "Signed in." : "Run codex login.")
+    };
+  },
+  invocation(input) {
+    return { bin: codexManifest.binaries[0], args: args(input) };
+  },
+  async run(input) {
+    const bin = await binary();
+    const argv = args(input);
+    const command = `${bin} ${argv.join(" ")}`;
+    const outcome = await runProcess({
+      bin,
+      args: argv,
+      cwd: input.cwd,
+      timeoutMs: input.settings.timeoutMs,
+      signal: input.signal,
+      logPath: input.logFile
+    });
+    let output = "";
+    if (input.outputFile) {
+      try {
+        output = readFileSync(input.outputFile, "utf8").trim();
+        rmSync(input.outputFile, { force: true });
+      } catch {
+        output = "";
+      }
+    }
+    if (!output) output = outcome.stdout;
+    if (outcome.aborted) {
+      return { ok: false, aborted: true, output, durationMs: outcome.durationMs, command };
+    }
+    if (outcome.timedOut) {
+      return {
+        ok: false,
+        output,
+        detail: `Codex did not finish within ${Math.round(input.settings.timeoutMs / 1e3)}s.`,
+        durationMs: outcome.durationMs,
+        command
+      };
+    }
+    return {
+      ok: outcome.code === 0,
+      output,
+      detail: outcome.code === 0 ? void 0 : outcome.stderr || `Exited with code ${outcome.code}.`,
+      durationMs: outcome.durationMs,
+      command
+    };
+  }
+});
+
+// src/agents/cursor-agent/events.ts
+function parse(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("{")) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+function textOf(event) {
+  return (event.message?.content ?? []).filter((part) => part.type === "text").map((part) => part.text ?? "").join("");
+}
+function describeTool(call, cwd) {
+  const [name, body] = Object.entries(call ?? {})[0] ?? [];
+  if (!name) return "a tool";
+  const verb = name.replace(/ToolCall$/, "").replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+  const args3 = body?.args ?? {};
+  const subject = args3.path ?? args3.command ?? args3.query ?? args3.pattern;
+  if (typeof subject !== "string") return verb;
+  const short = cwd && subject.startsWith(`${cwd}/`) ? subject.slice(cwd.length + 1) : subject;
+  return `${verb} ${short}`;
+}
+function describeEvent(line, cwd) {
+  const event = parse(line);
+  if (!event) return line.trim() === "" ? null : line;
+  switch (event.type) {
+    case "system":
+      return event.model ? `Started with ${event.model}.` : "Started.";
+    case "tool_call":
+      return event.subtype === "started" ? `Running ${describeTool(event.tool_call, cwd)}` : null;
+    case "assistant":
+      return null;
+    case "result": {
+      const seconds = event.duration_ms ? (event.duration_ms / 1e3).toFixed(0) : "?";
+      const tokens = event.usage?.outputTokens;
+      const spent = tokens === void 0 ? "" : `, ${tokens} tokens out`;
+      return event.is_error ? `Failed after ${seconds}s${spent}.` : `Answered after ${seconds}s${spent}.`;
+    }
+    default:
+      return null;
+  }
+}
+function answerFrom(stdout) {
+  const events = stdout.split("\n").map(parse);
+  const result = events.filter((event) => event?.type === "result").at(-1);
+  const failed = result?.is_error === true;
+  const whole = events.findLastIndex(
+    (event) => event?.type === "assistant" && event.timestamp_ms === void 0
+  );
+  if (whole >= 0) return { text: textOf(events[whole]).trim(), failed };
+  const lastTool = events.findLastIndex((event) => event?.type === "tool_call");
+  const partial = events.slice(lastTool + 1).filter((event) => event?.type === "assistant").map((event) => textOf(event));
+  if (partial.length > 0) return { text: partial.join("").trim(), failed };
+  return { text: (result?.result ?? "").trim(), failed };
+}
+
+// src/agents/cursor-agent/runtime.ts
+async function binary2() {
+  const found = await resolveBinary(cursorAgentManifest.binaries);
+  if (!found) throw new Error("The cursor-agent binary was not found on this host.");
+  return found;
+}
+function args2(input) {
+  const list = [
+    "-p",
+    // A stream of events rather than one block at the end: it can be watched
+    // while it runs, and the final answer arrives as a field of its own
+    // instead of as whatever reached stdout.
+    "--output-format",
+    "stream-json",
+    "--stream-partial-output",
+    "--workspace",
+    input.cwd,
+    // Without this the agent stops to ask whether the workspace is trusted,
+    // and in print mode there is nobody to answer.
+    "--trust"
+  ];
+  if (input.settings.permissionMode === "read_only") {
+    list.push("--mode", "ask");
+  } else {
+    list.push("--force");
+  }
+  if (input.settings.model) list.push("--model", input.settings.model);
+  list.push(input.prompt);
+  return list;
+}
+var cursorAgentRuntime = defineAgentRuntime({
+  async detect() {
+    const found = await resolveBinary(cursorAgentManifest.binaries);
+    if (!found) return { installed: false };
+    const version = await probe(found, ["--version"]);
+    return { installed: true, binaryPath: found, version: firstLine(version.text) };
+  },
+  async authStatus() {
+    const found = await resolveBinary(cursorAgentManifest.binaries);
+    if (!found) return { signedIn: false, detail: "Not installed." };
+    const result = await probe(found, ["status"]);
+    const detail = firstLine(result.text);
+    return {
+      signedIn: result.ok && !/not logged in|logged out/i.test(detail),
+      detail: detail || (result.ok ? "Signed in." : "Run cursor-agent login.")
+    };
+  },
+  invocation(input) {
+    return { bin: cursorAgentManifest.binaries[0], args: args2(input) };
+  },
+  async run(input) {
+    const bin = await binary2();
+    const argv = args2(input);
+    const outcome = await runProcess({
+      bin,
+      args: argv,
+      cwd: input.cwd,
+      timeoutMs: input.settings.timeoutMs,
+      signal: input.signal,
+      logPath: input.logFile,
+      logLine: (line) => describeEvent(line, input.cwd)
+    });
+    const command = `${bin} ${argv.join(" ")}`;
+    const answer = answerFrom(outcome.stdout);
+    if (outcome.aborted) {
+      return { ok: false, aborted: true, output: answer.text, durationMs: outcome.durationMs, command };
+    }
+    if (outcome.timedOut) {
+      return {
+        ok: false,
+        output: answer.text,
+        detail: `Cursor Agent did not finish within ${Math.round(input.settings.timeoutMs / 1e3)}s.`,
+        durationMs: outcome.durationMs,
+        command
+      };
+    }
+    return {
+      ok: outcome.code === 0 && !answer.failed,
+      output: answer.text,
+      detail: outcome.code === 0 && !answer.failed ? void 0 : answer.failed ? answer.text || "The agent reported an error." : outcome.stderr || `Exited with code ${outcome.code}.`,
+      durationMs: outcome.durationMs,
+      command
+    };
+  }
+});
+
+// src/agents/runtimes.ts
+var RUNTIMES = {
+  codex: codexRuntime,
+  "cursor-agent": cursorAgentRuntime
+};
+function agentRuntime(id) {
+  const runtime = RUNTIMES[id];
+  if (!runtime) throw new Error(`Unknown agent: ${id}`);
+  return runtime;
+}
+
+// src/agents/inventory.ts
+async function detectAgents() {
+  return Promise.all(
+    AGENT_MANIFESTS.map(async (manifest) => {
+      const runtime = agentRuntime(manifest.id);
+      const detection = await runtime.detect();
+      const auth = detection.installed ? await runtime.authStatus() : null;
+      return {
+        agentId: manifest.id,
+        installed: detection.installed,
+        version: detection.installed ? detection.version : null,
+        signedIn: Boolean(auth?.signedIn),
+        detail: auth?.detail ?? ""
+      };
+    })
+  );
+}
+
+// src/server/agent-runner.ts
+import { mkdirSync as mkdirSync2, writeFileSync } from "node:fs";
+import { join as join3 } from "node:path";
+
+// src/server/paths.ts
+import { mkdirSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+function isDevProfile() {
+  return process.env.LOOPABLE_DEV === "1";
+}
+function dataDir() {
+  const dir = process.env.LOOPABLE_HOME ?? join2(homedir2(), isDevProfile() ? ".loopable-dev" : ".loopable");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function runDir(taskId) {
+  const dir = join2(dataDir(), "runs", taskId);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// src/server/agent-runner.ts
+async function runAgentJob(job, options = {}) {
+  const workspace = options.workspace ?? runDir(job.taskId);
+  mkdirSync2(workspace, { recursive: true });
+  for (const file of job.files) {
+    writeFileSync(join3(workspace, file.name), file.body);
+  }
+  const logFile = join3(workspace, "agent.log");
+  const outputFile = join3(workspace, "answer.txt");
+  const cwd = job.cwd ?? workspace;
+  const run = options.run ?? ((input) => agentRuntime(job.agentId).run(input));
+  const result = await run({
+    prompt: job.prompt,
+    cwd,
+    settings: job.settings,
+    outputFile,
+    logFile,
+    signal: options.signal
+  });
+  return {
+    ok: result.ok,
+    output: result.output,
+    detail: result.detail,
+    aborted: result.aborted,
+    durationMs: result.durationMs,
+    command: result.command
+  };
+}
+
+// src/runner/client.ts
+async function json(url2, token, path, body) {
+  const res = await fetch(`${url2}${path}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  const text = await res.text();
+  let parsed = null;
+  try {
+    parsed = text ? JSON.parse(text) : null;
+  } catch {
+    parsed = { error: text };
+  }
+  if (!res.ok) {
+    const error = parsed?.error ?? res.statusText;
+    throw new Error(error);
+  }
+  return parsed;
+}
+function watchLog(path, onChunk) {
+  let offset = 0;
+  const flush = () => {
+    if (!existsSync(path)) return;
+    const fd = openSync(path, "r");
+    try {
+      const size = fstatSync(fd).size;
+      if (size <= offset) return;
+      const buf = Buffer.alloc(size - offset);
+      readSync(fd, buf, 0, buf.length, offset);
+      offset = size;
+      onChunk(buf.toString("utf8"));
+    } finally {
+      closeSync(fd);
+    }
+  };
+  const timer = setInterval(flush, 400);
+  return () => {
+    clearInterval(timer);
+    flush();
+  };
+}
+async function runRemoteLoop(input) {
+  const url2 = input.url.replace(/\/$/, "");
+  const inventory = await detectAgents();
+  const hello = await json(url2, input.joinToken, "/api/runners/hello", {
+    hostname: osHostname(),
+    inventory
+  });
+  input.log(`joined as ${hello.name} (${hello.runnerId})`);
+  const token = hello.runnerToken;
+  async function heartbeat() {
+    await json(url2, token, "/api/runners/heartbeat", { inventory: await detectAgents() });
+  }
+  await heartbeat();
+  const beat = setInterval(() => void heartbeat().catch((error) => {
+    input.log(`heartbeat failed: ${error instanceof Error ? error.message : String(error)}`);
+  }), 15e3);
+  let stopping = false;
+  const shutdown = () => {
+    stopping = true;
+    clearInterval(beat);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  while (!stopping) {
+    try {
+      const claimed = await json(url2, token, "/api/runners/claim", {});
+      if (!claimed.job) {
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        continue;
+      }
+      const job = claimed.job;
+      input.log(`running ${job.taskId}`);
+      const workspace = mkdtempSync(join4(tmpdir(), `loopable-${job.taskId}-`));
+      const stopLog = watchLog(join4(workspace, "agent.log"), (chunk) => {
+        void json(url2, token, `/api/runners/jobs/${job.taskId}/log`, { chunk }).catch((error) => {
+          input.log(`log failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+      });
+      try {
+        const result = await runAgentJob(job, { workspace });
+        await json(url2, token, `/api/runners/jobs/${job.taskId}/complete`, result);
+      } finally {
+        stopLog();
+        rmSync2(workspace, { recursive: true, force: true });
+      }
+    } catch (error) {
+      input.log(`claim failed: ${error instanceof Error ? error.message : String(error)}`);
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+    }
+  }
+}
+
+// src/runner/main.ts
+function log(message) {
+  process.stdout.write(`${(/* @__PURE__ */ new Date()).toISOString()} ${message}
+`);
+}
+var url = process.env.LOOPABLE_URL;
+var joinToken = process.env.LOOPABLE_RUNNER_TOKEN;
+if (!url || !joinToken) {
+  log("Set LOOPABLE_URL and LOOPABLE_RUNNER_TOKEN, then start again.");
+  process.exitCode = 1;
+} else {
+  await runRemoteLoop({ url, joinToken, log });
+}

package/drizzle/0000_cold_demogoblin.sql

@@ -0,0 +1,29 @@
+CREATE TABLE `auth_attempts` (
+	`state` text PRIMARY KEY NOT NULL,
+	`connector_id` text NOT NULL,
+	`verifier` text NOT NULL,
+	`redirect_uri` text NOT NULL,
+	`return_to` text,
+	`expires_at` integer NOT NULL,
+	`created_at` integer DEFAULT (unixepoch() * 1000) NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE `connections` (
+	`id` text PRIMARY KEY NOT NULL,
+	`connector_id` text NOT NULL,
+	`status` text DEFAULT 'connected' NOT NULL,
+	`account_id` text NOT NULL,
+	`account_label` text NOT NULL,
+	`account_url` text,
+	`avatar_url` text,
+	`scopes` text,
+	`settings` text DEFAULT '{}' NOT NULL,
+	`cursor` text,
+	`last_synced_at` integer,
+	`last_error` text,
+	`created_at` integer DEFAULT (unixepoch() * 1000) NOT NULL,
+	`updated_at` integer DEFAULT (unixepoch() * 1000) NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `connections_account_unique` ON `connections` (`connector_id`,`account_id`);--> statement-breakpoint
+CREATE INDEX `connections_connector_idx` ON `connections` (`connector_id`);

package/drizzle/0001_fancy_blonde_phantom.sql

@@ -0,0 +1,13 @@
+CREATE TABLE `agent_settings` (
+	`agent_id` text PRIMARY KEY NOT NULL,
+	`permission_mode` text NOT NULL,
+	`model` text,
+	`timeout_ms` integer NOT NULL,
+	`updated_at` integer DEFAULT (unixepoch() * 1000) NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE `app_settings` (
+	`key` text PRIMARY KEY NOT NULL,
+	`value` text NOT NULL,
+	`updated_at` integer DEFAULT (unixepoch() * 1000) NOT NULL
+);