@geraldmaron/construct 1.1.0 → 1.2.0

package/lib/chat/web-launcher.mjs

@@ -0,0 +1,63 @@
+/**
+ * lib/chat/web-launcher.mjs — start dashboard server and open /chat for construct chat --web.
+ *
+ * Reuses lib/service-manager.mjs startDashboard so the browser surface shares auth,
+ * CSRF, and static hosting with the operations dashboard.
+ */
+
+import { spawn } from 'node:child_process';
+import { startDashboard, readDashboardState } from '../service-manager.mjs';
+
+function openBrowser(url) {
+  const platform = process.platform;
+  let cmd;
+  let args;
+  if (platform === 'darwin') {
+    cmd = 'open';
+    args = [url];
+  } else if (platform === 'win32') {
+    cmd = 'cmd';
+    args = ['/c', 'start', '', url];
+  } else {
+    cmd = 'xdg-open';
+    args = [url];
+  }
+  try {
+    spawn(cmd, args, { detached: true, stdio: 'ignore' }).unref();
+  } catch {
+    /* browser open is best-effort */
+  }
+}
+
+export async function runWebChat({
+  cwd = process.cwd(),
+  env = process.env,
+  output = process.stdout,
+  errorOutput = process.stderr,
+  surface = null,
+} = {}) {
+  let dash = readDashboardState();
+  if (!dash?.port) {
+    const result = await startDashboard({ rootDir: cwd, preferredPort: parseInt(env.PORT || env.DASHBOARD_PORT || '4242', 10) });
+    if (result.started || result.reused) {
+      dash = { port: result.port, url: result.url || `http://127.0.0.1:${result.port}` };
+    } else {
+      errorOutput.write(`Failed to start dashboard: ${result.reason || 'unknown error'}\n`);
+      return 1;
+    }
+  }
+
+  const base = (dash.url || `http://127.0.0.1:${dash.port}`).replace(/\/$/, '');
+  const chatUrl = surface === 'desktop'
+    ? `${base}/chat/?surface=desktop`
+    : `${base}/chat/`;
+  output.write(`Construct web chat: ${chatUrl}\n`);
+  output.write('Press Ctrl-C to stop the dashboard server.\n');
+  openBrowser(chatUrl);
+
+  await new Promise((resolve) => {
+    process.once('SIGINT', resolve);
+    process.once('SIGTERM', resolve);
+  });
+  return 0;
+}

package/lib/chat/web-picker-keys.mjs

@@ -0,0 +1,46 @@
+/**
+ * lib/chat/web-picker-keys.mjs — keyboard routing for the web list picker.
+ *
+ * Arrow/enter/escape handling shared with Ink via list-picker.mjs; this module
+ * adapts DOM KeyboardEvent shapes for tests and the React overlay.
+ */
+
+import {
+  getPickerSelectedItem,
+  getPickerVisibleItems,
+  movePickerIndex,
+  reducePickerKey,
+} from './list-picker.mjs';
+
+export { getPickerSelectedItem, getPickerVisibleItems, movePickerIndex };
+
+export function domKeyToPickerKey(event) {
+  const key = event?.key || '';
+  return {
+    char: key.length === 1 && !event.ctrlKey && !event.metaKey && !event.altKey ? key : undefined,
+    key: {
+      escape: key === 'Escape',
+      return: key === 'Enter',
+      upArrow: key === 'ArrowUp',
+      downArrow: key === 'ArrowDown',
+      backspace: key === 'Backspace',
+      delete: key === 'Delete',
+      ctrl: event.ctrlKey,
+      meta: event.metaKey,
+    },
+  };
+}
+
+export function isPickerNavigationKey(key) {
+  return key === 'ArrowUp' || key === 'ArrowDown' || key === 'Enter' || key === 'Escape';
+}
+
+export function reduceWebPickerKey(state, event) {
+  return reducePickerKey(state, domKeyToPickerKey(event));
+}
+
+export function commitWebPickerSelection(state) {
+  const item = getPickerSelectedItem(state);
+  if (!item || item.disabled) return { ok: false, item: null };
+  return { ok: true, item };
+}

package/lib/chat/web-session.mjs

@@ -0,0 +1,159 @@
+/**
+ * lib/chat/web-session.mjs — owned-loop runtime factory for browser chat.
+ *
+ * Builds the same driver + session shape as lib/chat/cli.mjs so dashboard SSE
+ * and construct chat --web share one configuration path. One runtime instance
+ * is kept per conversation id for the lifetime of the server process.
+ */
+import { randomBytes } from 'crypto';
+import { createOwnedLoopDriver } from '../../apps/chat/engine/loop-driver.mjs';
+import { resolveChatModelSelectionAsync, resolveSessionModel } from '../../apps/chat/engine/models.mjs';
+import { loadChatConfig } from './config.mjs';
+import { loadConstructEnv } from '../env-config.mjs';
+import { resolveLayers } from './transparency.mjs';
+import { buildSystemPrompt } from './system-prompt.mjs';
+import { createSessionUsage } from './tui/usage.mjs';
+import { resolveExecutionCapabilityProfile } from '../models/execution-capability-profile.mjs';
+import { compileExecutionPolicy } from '../models/execution-policy.mjs';
+import { resolveDemoGuideForChat } from '../demo-surface.mjs';
+
+const runtimes = new Map();
+const pendingPermissions = new Map();
+
+function createPermissionHandler({ session, onPermission = null }) {
+  return async (req) => {
+    const mode = session.permissionMode || 'allow_once';
+    if (mode === 'reject') return 'reject';
+    if (mode === 'allow_always') return 'allow_always';
+    if (mode === 'allow_once') return 'allow';
+    if (mode === 'ask') {
+      const requestId = req.requestId || `perm-${randomBytes(8).toString('hex')}`;
+      onPermission?.({
+        type: 'permission',
+        requestId,
+        toolCall: { title: req.tool || req.toolCall?.title || 'tool', input: req.input ?? null },
+        options: ['allow', 'allow_always', 'reject'],
+      });
+      return new Promise((resolve) => {
+        pendingPermissions.set(requestId, { resolve, req, convId: session.convId });
+        setTimeout(() => {
+          if (pendingPermissions.has(requestId)) {
+            pendingPermissions.delete(requestId);
+            resolve('reject');
+          }
+        }, 120_000);
+      });
+    }
+    return 'allow';
+  };
+}
+
+export function resolveWebPermission(requestId, decision) {
+  const pending = pendingPermissions.get(requestId);
+  if (!pending) return false;
+  pendingPermissions.delete(requestId);
+  pending.resolve(decision);
+  return true;
+}
+
+export function listPendingPermissions(convId) {
+  return [...pendingPermissions.entries()]
+    .filter(([, p]) => p.convId === convId)
+    .map(([requestId, p]) => ({
+      requestId,
+      title: p.req?.toolCall?.title || 'tool',
+      options: p.req?.options || ['allow', 'reject'],
+    }));
+}
+
+export function getWebChatRuntime(convId) {
+  return runtimes.get(convId) || null;
+}
+
+export async function ensureWebChatRuntime({
+  convId,
+  cwd = process.cwd(),
+  env = process.env,
+  onPermission = null,
+} = {}) {
+  if (runtimes.has(convId)) return runtimes.get(convId);
+
+  const effectiveEnv = loadConstructEnv({ rootDir: cwd, env, warn: false });
+  const { config } = loadChatConfig({ cwd });
+  const layers = resolveLayers({ flags: {}, env: effectiveEnv });
+  for (const key of Object.keys(config.layers || {})) {
+    if (config.layers[key] === false) layers[key] = false;
+  }
+
+  let modelMode = config.modelMode || 'pinned';
+  let resolvedModel = config.model || null;
+  if (modelMode === 'free-router') {
+    const sessionStub = { modelMode: 'free-router', failedModels: new Set() };
+    resolvedModel = await resolveSessionModel(sessionStub, { env: effectiveEnv, tier: 'standard' });
+  }
+
+  const modelResolution = modelMode === 'free-router' && resolvedModel
+    ? { id: resolvedModel, notice: null }
+    : await resolveChatModelSelectionAsync({ env: effectiveEnv, requested: resolvedModel });
+
+  const demoName = effectiveEnv.CONSTRUCT_DEMO || null;
+  const demoPack = demoName ? resolveDemoGuideForChat(demoName, { cwd, repoRoot: cwd }) : null;
+
+  const session = {
+    convId,
+    model: modelResolution.id || resolvedModel,
+    modelMode,
+    permissionMode: config.permissionMode || 'allow_once',
+    sandbox: config.sandbox || 'workspace-write',
+    layers,
+    usage: createSessionUsage(),
+    demoGuide: demoPack?.guide || null,
+    demoTitle: demoPack?.script?.title || null,
+  };
+
+  const handlers = {
+    getSandbox: () => session.sandbox,
+    getPermissionMode: () => session.permissionMode,
+    requestPermission: createPermissionHandler({ session, onPermission }),
+  };
+
+  const { createAiSdkAgent } = await import('../../apps/chat/engine/ai-sdk-agent.mjs');
+  const driver = createOwnedLoopDriver({
+    env: effectiveEnv,
+    cwd,
+    model: session.model,
+    handlers,
+    systemPrompt: buildSystemPrompt({
+      capabilityTier: compileExecutionPolicy({
+        profile: resolveExecutionCapabilityProfile({ model: session.model }),
+      }).prompt.systemPromptTier,
+    }),
+    createAgent: (opts) => createAiSdkAgent(opts),
+  });
+
+  const runtime = { convId, driver, session, layers, cwd, env: effectiveEnv, _started: false };
+  runtimes.set(convId, runtime);
+
+  if (!demoPack?.guide) {
+    await driver.start();
+    runtime._started = true;
+  }
+
+  return runtime;
+}
+
+export async function ensureDriverStarted(runtime) {
+  if (!runtime || runtime._started) return runtime;
+  await runtime.driver.start();
+  runtime._started = true;
+  return runtime;
+}
+
+export const createWebChatRuntime = ensureWebChatRuntime;
+
+export function dropWebChatRuntime(convId) {
+  const runtime = runtimes.get(convId);
+  if (!runtime) return;
+  try { runtime.driver.stop?.(); } catch { /* already stopped */ }
+  runtimes.delete(convId);
+}