pragma-so 0.1.0

package/server/process/runCommand.ts

@@ -0,0 +1,142 @@
+import execa, { type ExecaChildProcess } from "execa";
+
+type CommonOptions = {
+  cwd: string;
+  env?: NodeJS.ProcessEnv;
+};
+
+export type CommandResult = {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+};
+
+export async function runCommand(input: {
+  command: string;
+  args?: string[];
+  cwd: string;
+  env?: NodeJS.ProcessEnv;
+}): Promise<string> {
+  const result = await runCommandDetailed(input);
+  return result.stdout;
+}
+
+export async function runCommandDetailed(input: {
+  command: string;
+  args?: string[];
+  cwd: string;
+  env?: NodeJS.ProcessEnv;
+}): Promise<CommandResult> {
+  const args = input.args ?? [];
+  const result = await execa(input.command, args, {
+    cwd: input.cwd,
+    env: input.env,
+    reject: false,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const exitCode = result.exitCode ?? -1;
+  if (exitCode !== 0) {
+    throw new Error(
+      `${input.command} ${args.join(" ")} failed (${exitCode}) in ${input.cwd}: ${
+        result.stderr.trim() || "unknown error"
+      }`,
+    );
+  }
+
+  return {
+    stdout: result.stdout,
+    stderr: result.stderr,
+    exitCode,
+  };
+}
+
+export async function runShellCommandDetailed(input: {
+  command: string;
+  cwd: string;
+  env?: NodeJS.ProcessEnv;
+}): Promise<CommandResult> {
+  const shellCommand =
+    process.platform === "win32" ? "cmd.exe" : "sh";
+  const shellArgs =
+    process.platform === "win32"
+      ? ["/d", "/s", "/c", input.command]
+      : ["-lc", input.command];
+
+  const result = await execa(shellCommand, shellArgs, {
+    cwd: input.cwd,
+    env: input.env,
+    reject: false,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  return {
+    stdout: result.stdout,
+    stderr: result.stderr,
+    exitCode: result.exitCode ?? -1,
+  };
+}
+
+export function spawnCommand(input: {
+  command: string;
+  args?: string[];
+  cwd: string;
+  env?: NodeJS.ProcessEnv;
+  stdio?: "pipe" | "inherit";
+  stdin?: "pipe" | "ignore" | "inherit";
+}): ExecaChildProcess<string> {
+  const args = input.args ?? [];
+  const stdio = input.stdio ?? "pipe";
+  const stdioOption = input.stdin
+    ? [input.stdin, stdio, stdio] as const
+    : stdio;
+  return execa(input.command, args, {
+    cwd: input.cwd,
+    env: input.env,
+    reject: false,
+    stdio: stdioOption,
+    buffer: stdio === "pipe",
+  });
+}
+
+export function spawnShellCommand(input: {
+  command: string;
+  cwd: string;
+  env?: NodeJS.ProcessEnv;
+  stdio?: "pipe" | "inherit";
+}): ExecaChildProcess<string> {
+  const stdio = input.stdio ?? "pipe";
+  const shellCommand = process.platform === "win32" ? "cmd.exe" : "sh";
+  const shellArgs =
+    process.platform === "win32"
+      ? ["/d", "/s", "/c", input.command]
+      : ["-lc", input.command];
+
+  return execa(shellCommand, shellArgs, {
+    cwd: input.cwd,
+    env: input.env,
+    reject: false,
+    stdio,
+    buffer: stdio === "pipe",
+  });
+}
+
+export function spawnNodeCommand(input: {
+  modulePath: string;
+  args?: string[];
+  cwd: string;
+  env?: NodeJS.ProcessEnv;
+  stdio?: "pipe" | "inherit";
+}): ExecaChildProcess<string> {
+  const args = input.args ?? [];
+  const stdio = input.stdio ?? "pipe";
+  return execa(process.execPath, [input.modulePath, ...args], {
+    cwd: input.cwd,
+    env: input.env,
+    reject: false,
+    stdio,
+    buffer: stdio === "pipe",
+  });
+}

package/server/stores/agentStore.ts

@@ -0,0 +1,167 @@
+import type { PGlite } from "@electric-sql/pglite";
+import type { HarnessId } from "../conversation/types";
+
+export type AgentRow = {
+  id: string;
+  name: string;
+  description: string | null;
+  status: string;
+  agent_file: string | null;
+  emoji: string | null;
+  harness: HarnessId;
+  model_label: string;
+  model_id: string;
+};
+
+export async function listAgents(db: PGlite): Promise<AgentRow[]> {
+  const result = await db.query<AgentRow>(
+    `SELECT id, name, description, status, agent_file, emoji, harness, model_label, model_id
+     FROM agents ORDER BY name ASC`,
+  );
+  return result.rows;
+}
+
+export async function getAgentById(
+  db: PGlite,
+  id: string,
+): Promise<{
+  id: string;
+  name: string;
+  harness: HarnessId;
+  model_label: string;
+  model_id: string;
+  agent_file: string | null;
+} | null> {
+  const result = await db.query<{
+    id: string;
+    name: string;
+    harness: HarnessId;
+    model_label: string;
+    model_id: string;
+    agent_file: string | null;
+  }>(
+    `SELECT id, name, harness, model_label, model_id, agent_file
+     FROM agents WHERE id = $1 LIMIT 1`,
+    [id],
+  );
+  return result.rows[0] ?? null;
+}
+
+export async function insertAgent(
+  db: PGlite,
+  input: {
+    id: string;
+    name: string;
+    description: string | null;
+    agent_file: string;
+    emoji: string;
+    harness: HarnessId;
+    model_label: string;
+    model_id: string;
+  },
+): Promise<void> {
+  await db.query(
+    `INSERT INTO agents (id, name, description, status, agent_file, emoji, harness, model_label, model_id)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
+    [input.id, input.name, input.description, "idle", input.agent_file, input.emoji, input.harness, input.model_label, input.model_id],
+  );
+}
+
+export async function updateAgent(
+  db: PGlite,
+  input: {
+    id: string;
+    name: string;
+    description: string | null;
+    agent_file: string;
+    emoji: string;
+    harness: HarnessId;
+    model_label: string;
+    model_id: string;
+  },
+): Promise<number> {
+  const result = await db.query(
+    `UPDATE agents
+     SET name = $2, description = $3, agent_file = $4, emoji = $5,
+         harness = $6, model_label = $7, model_id = $8
+     WHERE id = $1`,
+    [input.id, input.name, input.description, input.agent_file, input.emoji, input.harness, input.model_label, input.model_id],
+  );
+  return result.affectedRows ?? 0;
+}
+
+export async function deleteAgent(db: PGlite, id: string): Promise<number> {
+  await db.query(`UPDATE tasks SET assigned_to = NULL WHERE assigned_to = $1`, [id]);
+  const result = await db.query(`DELETE FROM agents WHERE id = $1`, [id]);
+  return result.affectedRows ?? 0;
+}
+
+export async function generateNextAgentId(db: PGlite, name: string): Promise<string> {
+  const base = normalizeAgentIdBase(name);
+  const likePattern = `${base}-%`;
+  const existing = await db.query<{ id: string }>(
+    `SELECT id FROM agents WHERE id = $1 OR id LIKE $2`,
+    [base, likePattern],
+  );
+
+  if (existing.rows.length === 0) {
+    return base;
+  }
+
+  let maxSuffix = -1;
+  const suffixRegex = new RegExp(`^${escapeRegex(base)}-(\\d+)$`);
+
+  for (const row of existing.rows) {
+    if (row.id === base) {
+      maxSuffix = Math.max(maxSuffix, 0);
+      continue;
+    }
+    const match = row.id.match(suffixRegex);
+    if (!match) continue;
+    const parsed = Number.parseInt(match[1], 10);
+    if (Number.isInteger(parsed)) {
+      maxSuffix = Math.max(maxSuffix, parsed);
+    }
+  }
+
+  return `${base}-${Math.max(1, maxSuffix + 1)}`;
+}
+
+export async function listPlanWorkerCandidates(
+  db: PGlite,
+  defaultAgentId: string,
+): Promise<Array<{
+  id: string;
+  name: string;
+  description: string | null;
+  harness: HarnessId;
+  model_label: string;
+}>> {
+  const result = await db.query<{
+    id: string;
+    name: string;
+    description: string | null;
+    harness: HarnessId;
+    model_label: string;
+  }>(
+    `SELECT id, name, description, harness, model_label
+     FROM agents WHERE id <> $1 ORDER BY name ASC`,
+    [defaultAgentId],
+  );
+  return result.rows;
+}
+
+function normalizeAgentIdBase(name: string): string {
+  const normalized = name
+    .trim()
+    .toLowerCase()
+    .replace(/\s+/g, "_")
+    .replace(/[^a-z0-9_-]/g, "_")
+    .replace(/_+/g, "_")
+    .replace(/^[_-]+|[_-]+$/g, "");
+  return normalized || "agent";
+}
+
+function escapeRegex(input: string): string {
+  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/server/stores/connectorStore.ts

@@ -0,0 +1,299 @@
+import type { PGlite } from "@electric-sql/pglite";
+
+export type ConnectorListRow = {
+  id: string;
+  name: string;
+  display_name: string | null;
+  description: string | null;
+  provider: string;
+  status: string;
+  auth_type: string;
+  oauth_client_id: string | null;
+  oauth_client_secret: string | null;
+};
+
+export type ConnectorAuthRow = {
+  id: string;
+  name: string;
+  oauth_client_id: string | null;
+  oauth_client_secret: string | null;
+  oauth_auth_url: string;
+  scopes: string;
+  redirect_uri: string;
+  auth_type: string;
+};
+
+export type ConnectorTokenRow = {
+  id: string;
+  oauth_client_id: string;
+  oauth_client_secret: string;
+  oauth_token_url: string;
+  redirect_uri: string;
+};
+
+export async function listConnectors(db: PGlite): Promise<ConnectorListRow[]> {
+  const result = await db.query<ConnectorListRow>(
+    `SELECT id, name, display_name, description, provider, status, auth_type,
+            oauth_client_id, oauth_client_secret
+     FROM connectors ORDER BY name ASC`,
+  );
+  return result.rows;
+}
+
+export async function getConnectorAuthInfo(
+  db: PGlite,
+  connectorId: string,
+): Promise<ConnectorAuthRow | null> {
+  const result = await db.query<ConnectorAuthRow>(
+    `SELECT id, name, oauth_client_id, oauth_client_secret, oauth_auth_url,
+            scopes, redirect_uri, auth_type
+     FROM connectors WHERE id = $1 LIMIT 1`,
+    [connectorId],
+  );
+  return result.rows[0] ?? null;
+}
+
+export async function getConnectorForConfig(
+  db: PGlite,
+  connectorId: string,
+): Promise<{ id: string; name: string; auth_type: string } | null> {
+  const result = await db.query<{ id: string; name: string; auth_type: string }>(
+    `SELECT id, name, auth_type FROM connectors WHERE id = $1 LIMIT 1`,
+    [connectorId],
+  );
+  return result.rows[0] ?? null;
+}
+
+export async function setConnectorApiKeyToken(
+  db: PGlite,
+  connectorId: string,
+  accessToken: string,
+): Promise<void> {
+  await db.query(
+    `UPDATE connectors SET access_token = $1, status = 'connected' WHERE id = $2`,
+    [accessToken, connectorId],
+  );
+}
+
+export async function updateConnectorOAuthConfig(
+  db: PGlite,
+  connectorId: string,
+  updates: { oauth_client_id?: string | null; oauth_client_secret?: string | null },
+): Promise<void> {
+  const sets: string[] = [];
+  const params: unknown[] = [connectorId];
+  let paramIndex = 2;
+
+  if (updates.oauth_client_id !== undefined) {
+    sets.push(`oauth_client_id = $${paramIndex++}`);
+    params.push(updates.oauth_client_id || null);
+  }
+  if (updates.oauth_client_secret !== undefined) {
+    sets.push(`oauth_client_secret = $${paramIndex++}`);
+    params.push(updates.oauth_client_secret || null);
+  }
+
+  if (sets.length > 0) {
+    sets.push(`status = 'disconnected'`);
+    await db.query(`UPDATE connectors SET ${sets.join(", ")} WHERE id = $1`, params);
+  }
+}
+
+export async function connectorExists(db: PGlite, connectorId: string): Promise<boolean> {
+  const result = await db.query<{ id: string }>(
+    `SELECT id FROM connectors WHERE id = $1 LIMIT 1`,
+    [connectorId],
+  );
+  return result.rows.length > 0;
+}
+
+export async function storeConnectorTokens(
+  db: PGlite,
+  connectorId: string,
+  accessToken: string,
+  refreshToken: string | null,
+  tokenExpiresAt: string,
+): Promise<void> {
+  await db.query(
+    `UPDATE connectors
+     SET access_token = $1, refresh_token = $2, token_expires_at = $3, status = 'connected'
+     WHERE id = $4`,
+    [accessToken, refreshToken, tokenExpiresAt, connectorId],
+  );
+}
+
+export async function disconnectConnector(db: PGlite, connectorId: string): Promise<void> {
+  await db.query(
+    `UPDATE connectors
+     SET status = 'disconnected', access_token = NULL,
+         refresh_token = NULL, token_expires_at = NULL
+     WHERE id = $1`,
+    [connectorId],
+  );
+}
+
+export async function refreshConnectorToken(
+  db: PGlite,
+  connector: {
+    id: string;
+    name: string;
+    access_token: string | null;
+    refresh_token: string | null;
+    token_expires_at: string | null;
+    oauth_token_url: string;
+    oauth_client_id: string | null;
+    oauth_client_secret: string | null;
+    auth_type: string;
+  },
+  proxyUrl: string,
+  proxyProvider: string | undefined,
+  hasCustomCredentials: boolean,
+): Promise<string> {
+  if (connector.auth_type === "api_key") {
+    return connector.access_token!;
+  }
+
+  if (connector.token_expires_at && new Date(connector.token_expires_at) > new Date()) {
+    return connector.access_token!;
+  }
+
+  if (!connector.refresh_token) {
+    throw new Error("No refresh token available — connector needs re-authorization");
+  }
+
+  let response: Response;
+
+  if (proxyProvider && !hasCustomCredentials) {
+    response = await fetch(`${proxyUrl}/refresh/${proxyProvider}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ refresh_token: connector.refresh_token }),
+    });
+  } else {
+    response = await fetch(connector.oauth_token_url, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: connector.refresh_token,
+        client_id: connector.oauth_client_id!,
+        client_secret: connector.oauth_client_secret!,
+      }),
+    });
+  }
+
+  if (!response.ok) {
+    await db.query(
+      `UPDATE connectors SET status = 'disconnected', access_token = NULL,
+       refresh_token = NULL, token_expires_at = NULL WHERE id = $1`,
+      [connector.id],
+    );
+    throw new Error("Token refresh failed — connector disconnected");
+  }
+
+  const data = (await response.json()) as {
+    access_token: string;
+    refresh_token?: string;
+    expires_in?: number;
+  };
+
+  await db.query(
+    `UPDATE connectors SET access_token = $1, refresh_token = COALESCE($2, refresh_token),
+     token_expires_at = $3 WHERE id = $4`,
+    [
+      data.access_token,
+      data.refresh_token ?? null,
+      new Date(Date.now() + (data.expires_in ?? 3600) * 1000).toISOString(),
+      connector.id,
+    ],
+  );
+
+  return data.access_token;
+}
+
+export async function getConnectorName(db: PGlite, connectorId: string): Promise<string | null> {
+  const result = await db.query<{ name: string }>(
+    `SELECT name FROM connectors WHERE id = $1 LIMIT 1`,
+    [connectorId],
+  );
+  return result.rows[0]?.name ?? null;
+}
+
+export async function getAgentConnectors(
+  db: PGlite,
+  agentId: string,
+): Promise<Array<{ id: string; name: string; description: string | null; status: string }>> {
+  const result = await db.query<{
+    id: string;
+    name: string;
+    description: string | null;
+    status: string;
+  }>(
+    `SELECT c.id, c.name, c.description, c.status
+     FROM connectors c
+     JOIN agent_connectors ac ON ac.connector_id = c.id
+     WHERE ac.agent_id = $1
+     ORDER BY c.name ASC`,
+    [agentId],
+  );
+  return result.rows;
+}
+
+export async function assignAgentConnector(
+  db: PGlite,
+  agentId: string,
+  connectorId: string,
+): Promise<void> {
+  await db.query(
+    `INSERT INTO agent_connectors (agent_id, connector_id) VALUES ($1, $2) ON CONFLICT DO NOTHING`,
+    [agentId, connectorId],
+  );
+}
+
+export async function unassignAgentConnector(
+  db: PGlite,
+  agentId: string,
+  connectorId: string,
+): Promise<number> {
+  const result = await db.query(
+    `DELETE FROM agent_connectors WHERE agent_id = $1 AND connector_id = $2`,
+    [agentId, connectorId],
+  );
+  return result.affectedRows ?? 0;
+}
+
+export async function getAgentConnectorContent(
+  db: PGlite,
+  agentId: string,
+  connectorId: string,
+): Promise<string | null> {
+  const result = await db.query<{ content: string }>(
+    `SELECT c.content
+     FROM connectors c
+     JOIN agent_connectors ac ON ac.connector_id = c.id
+     WHERE ac.agent_id = $1 AND c.id = $2
+     LIMIT 1`,
+    [agentId, connectorId],
+  );
+  return result.rows[0]?.content ?? null;
+}
+
+export async function getConnectorTokenInfo(
+  db: PGlite,
+  connectorId: string,
+): Promise<ConnectorTokenRow | null> {
+  const result = await db.query<ConnectorTokenRow>(
+    `SELECT id, oauth_client_id, oauth_client_secret, oauth_token_url, redirect_uri
+     FROM connectors WHERE id = $1 LIMIT 1`,
+    [connectorId],
+  );
+  return result.rows[0] ?? null;
+}
+
+export async function agentExists(db: PGlite, agentId: string): Promise<boolean> {
+  const result = await db.query<{ id: string }>(
+    `SELECT id FROM agents WHERE id = $1 LIMIT 1`,
+    [agentId],
+  );
+  return result.rows.length > 0;
+}

package/server/stores/humanStore.ts

@@ -0,0 +1,28 @@
+import type { PGlite } from "@electric-sql/pglite";
+
+export type HumanRow = {
+  id: string;
+  emoji: string;
+  created_at: string;
+};
+
+export async function listHumans(db: PGlite): Promise<HumanRow[]> {
+  const result = await db.query<HumanRow>(
+    `SELECT id, emoji, created_at FROM humans ORDER BY created_at ASC`,
+  );
+  return result.rows;
+}
+
+export async function insertHuman(db: PGlite, id: string, emoji: string): Promise<void> {
+  await db.query(`INSERT INTO humans (id, emoji) VALUES ($1, $2)`, [id, emoji]);
+}
+
+export async function updateHuman(db: PGlite, id: string, emoji: string): Promise<number> {
+  const result = await db.query(`UPDATE humans SET emoji = $2 WHERE id = $1`, [id, emoji]);
+  return result.affectedRows ?? 0;
+}
+
+export async function deleteHuman(db: PGlite, id: string): Promise<number> {
+  const result = await db.query(`DELETE FROM humans WHERE id = $1`, [id]);
+  return result.affectedRows ?? 0;
+}