opencandle 0.5.0 → 0.7.0

package/src/memory/tool-defaults.ts

@@ -3,60 +3,81 @@ import { initDefaultDatabase } from "./sqlite.js";
 export type ToolDefaults = Record<string, unknown>;
 type SqliteDb = ReturnType<typeof initDefaultDatabase>;
 
-export function getDefaults(toolName: string, db: SqliteDb = initDefaultDatabase()): ToolDefaults {
-  const rows = db
-    .prepare(
-      `SELECT param_path, value_json FROM tool_defaults WHERE tool_name = ? ORDER BY param_path`,
-    )
-    .all(toolName) as Array<{ param_path: string; value_json: string }>;
+export function getDefaults(toolName: string, db?: SqliteDb): ToolDefaults {
+  const ownedDb = db == null;
+  const connection = db ?? initDefaultDatabase();
+  try {
+    const rows = connection
+      .prepare(
+        `SELECT param_path, value_json FROM tool_defaults WHERE tool_name = ? ORDER BY param_path`,
+      )
+      .all(toolName) as Array<{ param_path: string; value_json: string }>;
 
-  const defaults: ToolDefaults = {};
-  for (const row of rows) {
-    setPath(defaults, row.param_path, parseStoredValue(row.value_json));
+    const defaults: ToolDefaults = {};
+    for (const row of rows) {
+      setPath(defaults, row.param_path, parseStoredValue(row.value_json));
+    }
+    return defaults;
+  } finally {
+    if (ownedDb) connection.close();
   }
-  return defaults;
 }
 
-export function getAllDefaults(db: SqliteDb = initDefaultDatabase()): Map<string, ToolDefaults> {
-  const rows = db
-    .prepare(
-      `SELECT tool_name, param_path, value_json FROM tool_defaults ORDER BY tool_name, param_path`,
-    )
-    .all() as Array<{ tool_name: string; param_path: string; value_json: string }>;
+export function getAllDefaults(db?: SqliteDb): Map<string, ToolDefaults> {
+  const ownedDb = db == null;
+  const connection = db ?? initDefaultDatabase();
+  try {
+    const rows = connection
+      .prepare(
+        `SELECT tool_name, param_path, value_json FROM tool_defaults ORDER BY tool_name, param_path`,
+      )
+      .all() as Array<{ tool_name: string; param_path: string; value_json: string }>;
 
-  const groups = new Map<string, ToolDefaults>();
-  for (const row of rows) {
-    const defaults = groups.get(row.tool_name) ?? {};
-    setPath(defaults, row.param_path, parseStoredValue(row.value_json));
-    groups.set(row.tool_name, defaults);
+    const groups = new Map<string, ToolDefaults>();
+    for (const row of rows) {
+      const defaults = groups.get(row.tool_name) ?? {};
+      setPath(defaults, row.param_path, parseStoredValue(row.value_json));
+      groups.set(row.tool_name, defaults);
+    }
+    return groups;
+  } finally {
+    if (ownedDb) connection.close();
   }
-  return groups;
 }
 
 export function setDefault(
   toolName: string,
   paramPath: string,
   value: unknown,
-  db: SqliteDb = initDefaultDatabase(),
+  db?: SqliteDb,
 ): void {
-  db.prepare(
-    `INSERT INTO tool_defaults (tool_name, param_path, value_json, set_at)
-     VALUES (?, ?, ?, ?)
-     ON CONFLICT(tool_name, param_path) DO UPDATE SET
-       value_json = excluded.value_json,
-       set_at = excluded.set_at`,
-  ).run(toolName, paramPath, JSON.stringify(value), new Date().toISOString());
+  const ownedDb = db == null;
+  const connection = db ?? initDefaultDatabase();
+  try {
+    connection
+      .prepare(
+        `INSERT INTO tool_defaults (tool_name, param_path, value_json, set_at)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(tool_name, param_path) DO UPDATE SET
+         value_json = excluded.value_json,
+         set_at = excluded.set_at`,
+      )
+      .run(toolName, paramPath, JSON.stringify(value), new Date().toISOString());
+  } finally {
+    if (ownedDb) connection.close();
+  }
 }
 
-export function clearDefault(
-  toolName: string,
-  paramPath: string,
-  db: SqliteDb = initDefaultDatabase(),
-): void {
-  db.prepare(`DELETE FROM tool_defaults WHERE tool_name = ? AND param_path = ?`).run(
-    toolName,
-    paramPath,
-  );
+export function clearDefault(toolName: string, paramPath: string, db?: SqliteDb): void {
+  const ownedDb = db == null;
+  const connection = db ?? initDefaultDatabase();
+  try {
+    connection
+      .prepare(`DELETE FROM tool_defaults WHERE tool_name = ? AND param_path = ?`)
+      .run(toolName, paramPath);
+  } finally {
+    if (ownedDb) connection.close();
+  }
 }
 
 function parseStoredValue(valueJson: string): unknown {

package/src/memory/types.ts

@@ -17,10 +17,10 @@ export interface MemoryEntry {
 
 /** Staleness thresholds in milliseconds per category. */
 export const STALENESS_THRESHOLDS: Record<MemoryCategory, number> = {
-  investor_profile: 90 * 24 * 60 * 60 * 1000,    // 90 days
+  investor_profile: 90 * 24 * 60 * 60 * 1000, // 90 days
   interaction_feedback: 14 * 24 * 60 * 60 * 1000, // 14 days
-  workflow_history: 7 * 24 * 60 * 60 * 1000,      // 7 days
-  references: 30 * 24 * 60 * 60 * 1000,           // 30 days
+  workflow_history: 7 * 24 * 60 * 60 * 1000, // 7 days
+  references: 30 * 24 * 60 * 60 * 1000, // 30 days
 };
 
 /** Map preference keys to memory categories. */

package/src/monitor.ts

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import "./infra/node-version.js";
+import { parseArgs } from "node:util";
+import { loadEnv } from "./config.js";
+import { runLocalAutomationHeartbeat } from "./market-state/local-automation-service.js";
+import { MarketStateService } from "./market-state/service.js";
+import { initDefaultDatabase } from "./memory/sqlite.js";
+
+const DEFAULT_MONITOR_INTERVAL_MS = 60_000;
+const MIN_MONITOR_INTERVAL_MS = 5_000;
+const MONITOR_OWNER_ID = `monitor:${process.pid}`;
+
+interface MonitorOptions {
+  once: boolean;
+  intervalMs: number;
+}
+
+function parseMonitorOptions(argv = process.argv.slice(2)): MonitorOptions {
+  const parsed = parseArgs({
+    args: argv,
+    options: {
+      once: { type: "boolean", default: false },
+      "interval-ms": { type: "string" },
+    },
+    strict: false,
+  });
+  return {
+    once: parsed.values.once === true,
+    intervalMs: normalizeMonitorIntervalMs(parsed.values["interval-ms"]),
+  };
+}
+
+function normalizeMonitorIntervalMs(raw: string | boolean | undefined): number {
+  if (typeof raw !== "string" || raw.trim() === "") return DEFAULT_MONITOR_INTERVAL_MS;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < MIN_MONITOR_INTERVAL_MS)
+    return DEFAULT_MONITOR_INTERVAL_MS;
+  return Math.floor(parsed);
+}
+
+async function runMonitorHeartbeat(
+  intervalMs: number,
+  releaseLeaseOnComplete = false,
+): Promise<void> {
+  const db = initDefaultDatabase();
+  const now = new Date().toISOString();
+  try {
+    const result = await runLocalAutomationHeartbeat(db, {
+      ownerId: MONITOR_OWNER_ID,
+      ownerKind: "monitor",
+      now,
+      ttlSeconds: Math.max(90, Math.ceil((intervalMs * 2) / 1000)),
+      checkAlerts: true,
+      checkReports: true,
+      releaseLeaseOnComplete,
+    });
+    if (!result.lease.acquired) {
+      console.log(
+        `OpenCandle monitor standby: runner owned by ${result.lease.ownerId} until ${result.lease.expiresAt}`,
+      );
+      return;
+    }
+    const alertSummary = result.alertCheck
+      ? `${result.alertCheck.checked} alert(s), ${result.alertCheck.triggered} triggered, ${result.alertCheck.unavailable} unavailable`
+      : "no due alerts";
+    const reportSummary = result.reportRuns.length
+      ? `${result.reportRuns.length} report run(s)`
+      : "no due reports";
+    console.log(`OpenCandle monitor heartbeat ${now}: ${alertSummary}; ${reportSummary}.`);
+  } finally {
+    db.close();
+  }
+}
+
+async function main(): Promise<void> {
+  loadEnv();
+  const options = parseMonitorOptions();
+  let inFlight = false;
+  const runOnce = async (): Promise<void> => {
+    if (inFlight) {
+      console.log("OpenCandle monitor heartbeat skipped: previous run is still active.");
+      return;
+    }
+    inFlight = true;
+    try {
+      await runMonitorHeartbeat(options.intervalMs, options.once);
+    } finally {
+      inFlight = false;
+    }
+  };
+
+  await runOnce();
+  if (options.once) return;
+
+  console.log(
+    `OpenCandle monitor running locally every ${options.intervalMs}ms. Keep this process open for local alerts and reports.`,
+  );
+  const timer = setInterval(() => {
+    void runOnce().catch((error) => {
+      console.error(
+        `OpenCandle monitor heartbeat failed: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    });
+  }, options.intervalMs);
+
+  const stop = () => {
+    clearInterval(timer);
+    const db = initDefaultDatabase();
+    try {
+      new MarketStateService(db).releaseAutomationRunnerLease(MONITOR_OWNER_ID);
+    } finally {
+      db.close();
+    }
+    console.log("OpenCandle monitor stopped.");
+    process.exit(0);
+  };
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+}
+
+await main();

package/src/onboarding/connect.ts

@@ -18,23 +18,21 @@
 // call will surface any lingering issue via the credential-required tag.
 
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { openInBrowser } from "../infra/open-url.js";
 import {
-  loadFileConfig,
-  saveFileConfig,
   loadConfig,
+  loadFileConfig,
   type OpenCandleFileConfig,
+  saveFileConfig,
 } from "../config.js";
+import { openInBrowser } from "../infra/open-url.js";
 import {
-  getProvider,
+  type ApiKeyProviderId,
   getCredentialSource,
+  getProvider,
+  isApiKeyProvider,
   type ProviderId,
 } from "./providers.js";
-import {
-  loadOnboardingState,
-  markProviderCompleted,
-  saveOnboardingState,
-} from "./state.js";
+import { loadOnboardingState, markProviderCompleted, saveOnboardingState } from "./state.js";
 import { validateCredential } from "./validation.js";
 
 export type ConnectResult =
@@ -55,9 +53,7 @@ function writeNested(
     next[head] = value;
   } else {
     const child =
-      next[head] && typeof next[head] === "object"
-        ? (next[head] as Record<string, unknown>)
-        : {};
+      next[head] && typeof next[head] === "object" ? (next[head] as Record<string, unknown>) : {};
     next[head] = writeNested(child, rest, value);
   }
   return next;
@@ -74,17 +70,13 @@ function writeNested(
  * provider-setup form. Validation is the caller's responsibility — both
  * call sites run `validateCredential` before invoking this helper.
  */
-export function persistProviderCredential(
-  providerId: ProviderId,
-  key: string,
-): void {
+export function persistProviderCredential(providerId: ApiKeyProviderId, key: string): void {
   const descriptor = getProvider(providerId);
+  if (!isApiKeyProvider(descriptor)) {
+    throw new Error(`Provider ${providerId} does not accept API keys`);
+  }
   const existing = loadFileConfig() as unknown as Record<string, unknown>;
-  const updated = writeNested(
-    existing,
-    descriptor.configPath,
-    key,
-  ) as OpenCandleFileConfig;
+  const updated = writeNested(existing, descriptor.configPath, key) as OpenCandleFileConfig;
   saveFileConfig(updated);
   loadConfig();
   const state = loadOnboardingState();
@@ -105,6 +97,13 @@ export async function runProviderConnect(
   providerId: ProviderId,
 ): Promise<ConnectResult> {
   const descriptor = getProvider(providerId);
+  if (!isApiKeyProvider(descriptor)) {
+    ctx.ui.notify(
+      `${descriptor.displayName} is not configured with an API key. Run opencandle doctor for setup status.`,
+      "warning",
+    );
+    return { status: "cancelled" };
+  }
 
   // Env-precedence check.
   if (getCredentialSource(providerId) === "env") {
@@ -121,10 +120,7 @@ export async function runProviderConnect(
   // the browser can't be opened, the user can still paste a key they
   // already have, so we continue rather than bailing.
   await openInBrowser(descriptor.signupUrl).catch(() => {});
-  ctx.ui.notify(
-    `Opening ${descriptor.displayName} signup in your browser...`,
-    "info",
-  );
+  ctx.ui.notify(`Opening ${descriptor.displayName} signup in your browser...`, "info");
 
   // Prompt for the key. Uses the provider's instructionsHint as the
   // placeholder text to remind the user what they're pasting.
@@ -144,7 +140,7 @@ export async function runProviderConnect(
   // short-circuit here without writing anything; transient failures warn
   // but proceed to persist so users don't get stuck on a provider outage.
   ctx.ui.notify(`Verifying your ${descriptor.displayName} key...`, "info");
-  const validation = await validateCredential(providerId, trimmed);
+  const validation = await validateCredential(descriptor.id, trimmed);
 
   if (validation.status === "invalid") {
     const statusHint =
@@ -173,12 +169,9 @@ export async function runProviderConnect(
     // Fall through to persist.
   }
 
-  persistProviderCredential(providerId, trimmed);
+  persistProviderCredential(descriptor.id, trimmed);
 
-  ctx.ui.notify(
-    `${descriptor.displayName} connected. Your key has been saved.`,
-    "info",
-  );
+  ctx.ui.notify(`${descriptor.displayName} connected. Your key has been saved.`, "info");
 
   return { status: "connected" };
 }

package/src/onboarding/credential-interceptor.ts

@@ -54,10 +54,7 @@ function buildRemediation(providerId: ProviderId): string {
   return `run /connect ${alias} to unlock`;
 }
 
-function skip(
-  providerId: ProviderId,
-  silenced: boolean,
-): InterceptAction {
+function skip(providerId: ProviderId, silenced: boolean): InterceptAction {
   return {
     action: "skip",
     provider: providerId,
@@ -74,17 +71,8 @@ function skip(
  *
  * No side effects. No Pi imports. Trivially unit-testable.
  */
-export function resolveCredentialRequired(
-  input: InterceptInput,
-): InterceptAction {
-  const {
-    provider,
-    reason,
-    state,
-    sessionPromptedSet,
-    hardPromptFiredInWorkflow,
-    now,
-  } = input;
+export function resolveCredentialRequired(input: InterceptInput): InterceptAction {
+  const { provider, reason, state, sessionPromptedSet, hardPromptFiredInWorkflow, now } = input;
 
   const descriptor = getProvider(provider);
   const entry = state.providers[provider];

package/src/onboarding/degradation-accumulator.ts

@@ -58,9 +58,7 @@ export function createDegradationAccumulator(): DegradationAccumulator {
         const silenced = entry?.status === "never_ask";
         const alias = descriptor.aliases[0] ?? descriptor.id;
         const baseRemediation = `run /connect ${alias} to unlock`;
-        const remediation = silenced
-          ? `${baseRemediation} (silenced)`
-          : baseRemediation;
+        const remediation = silenced ? `${baseRemediation} (silenced)` : baseRemediation;
         lines.push(
           buildSkippedTag({
             provider,