@bahulam/code 0.1.6 → 0.1.8

package/src/local-service/approval-bridge.mjs

@@ -0,0 +1,222 @@
+import { randomUUID } from 'node:crypto';
+import { ApprovalManager } from '../core/approval.mjs';
+
+const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
+
+export class BrowserApprovalManager extends ApprovalManager {
+  constructor({ emit, timeoutMs = DEFAULT_TIMEOUT_MS, ...options } = {}) {
+    super({ ...options, autoApprove: false });
+    if (typeof emit !== 'function') throw new Error('BrowserApprovalManager requires emit');
+    this.emit = emit;
+    this.timeoutMs = timeoutMs;
+    this.pending = new Map();
+  }
+
+  setAutoMode(enabled) {
+    this.autoApprove = false;
+    this.approveAll = Boolean(enabled);
+    if (!enabled) this.approvedToolTypes.clear();
+    return this.browserSummary();
+  }
+
+  browserSummary() {
+    const summary = this.getSummary();
+    return {
+      mode: this.approveAll ? 'auto' : 'ask',
+      auto: Boolean(this.approveAll),
+      total: summary.total,
+      approved: summary.approved,
+      denied: summary.denied,
+      trust: summary.trust,
+    };
+  }
+
+  _optionsFor(tier, toolName, args) {
+    return super._optionsFor(tier, toolName, args)
+      .filter((option) => option.value === 'approve' || option.value === 'reject');
+  }
+
+  async _prompt(toolName, args, context = {}) {
+    const tier = context.tier;
+    const why = context.reason || context.why || '';
+    const options = this._optionsFor(tier, toolName, args);
+    const approvalId = `approval_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
+    const prompt = promptForBrowser(toolName, args, tier, why);
+
+    this.emit('agent_approval_required', {
+      approval_id: approvalId,
+      tool_id: context.tool_id || context.call_id || context.request_id || '',
+      call_id: context.call_id || context.request_id || context.tool_id || '',
+      tool: toolName,
+      args: args || {},
+      tier,
+      reason: why,
+      prompt,
+      options: options.map((option) => ({
+        key: option.key,
+        label: option.label,
+        value: option.value,
+        hint: option.hint || '',
+      })),
+    });
+
+    return await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(approvalId);
+        const reason = `Approval timed out for ${toolName}`;
+        this.history.push({ tool: toolName, decision: 'timeout', tier, time: Date.now(), reason });
+        this.approvalLog.append({ tool: toolName, args, tier, decision: 'timeout', scope: 'once', reason, prompt });
+        this._rememberRejection({ tool: toolName, args, tier, decision: 'reject', reason, note: '' });
+        this.emit('agent_approval_resolved', {
+          approval_id: approvalId,
+          tool_id: context.tool_id || context.call_id || context.request_id || '',
+          call_id: context.call_id || context.request_id || context.tool_id || '',
+          tool: toolName,
+          approved: false,
+          reason,
+        });
+        resolve({ approved: false, tier, reason });
+      }, this.timeoutMs);
+
+      this.pending.set(approvalId, {
+        toolName,
+        args: args || {},
+        tier,
+        prompt,
+        options,
+        resolve: (decision) => {
+          clearTimeout(timer);
+          resolve(this._decisionResult(decision, { approvalId, toolName, args: args || {}, tier, prompt, context }));
+        },
+      });
+    });
+  }
+
+  decide(approvalId, decision = {}) {
+    const pending = this.pending.get(approvalId);
+    if (!pending) {
+      const err = new Error(`Approval request not found or already resolved: ${approvalId}`);
+      err.code = 'NOT_FOUND';
+      throw err;
+    }
+    this.pending.delete(approvalId);
+    pending.resolve(decision);
+    return { ok: true, approval_id: approvalId };
+  }
+
+  rejectAll(reason = 'Local workspace session closed') {
+    for (const [approvalId, pending] of this.pending.entries()) {
+      this.pending.delete(approvalId);
+      pending.resolve({ decision: 'reject', reason });
+    }
+  }
+
+  _decisionResult(decision, { approvalId, toolName, args, tier, prompt, context = {} }) {
+    const value = normalizeDecision(decision);
+    const note = String(decision?.reason || decision?.note || '').trim();
+
+    switch (value) {
+      case 'approve':
+        this.history.push({ tool: toolName, decision: 'yes', tier, time: Date.now() });
+        this.approvalLog.append({ tool: toolName, args, tier, decision: 'approve', scope: 'once', prompt });
+        this.emitResolved(approvalId, toolName, true, 'once', '', context);
+        return { approved: true, tier, scope: 'once' };
+
+      case 'allow-session': {
+        if (!this.policy.hitl?.allowSessionTrust) {
+          this.history.push({ tool: toolName, decision: 'yes', tier, time: Date.now() });
+          this.approvalLog.append({ tool: toolName, args, tier, decision: 'approve', scope: 'once', prompt });
+          this.emitResolved(approvalId, toolName, true, 'once', '', context);
+          return { approved: true, tier, scope: 'once' };
+        }
+        const rule = this.trustStore.add({ tool: toolName, args, tier, scope: 'SESSION' });
+        this.history.push({ tool: toolName, decision: 'session-trust', tier, time: Date.now(), rule_id: rule.id });
+        this.approvalLog.append({ tool: toolName, args, tier, decision: 'approve_trusted', scope: 'SESSION', rule_id: rule.id, prompt });
+        this.emitResolved(approvalId, toolName, true, 'SESSION', '', context);
+        return { approved: true, tier, scope: 'SESSION', rule_id: rule.id };
+      }
+
+      case 'allow-project': {
+        if (!this.policy.hitl?.allowProjectTrust) {
+          this.history.push({ tool: toolName, decision: 'yes', tier, time: Date.now() });
+          this.approvalLog.append({ tool: toolName, args, tier, decision: 'approve', scope: 'once', prompt });
+          this.emitResolved(approvalId, toolName, true, 'once', '', context);
+          return { approved: true, tier, scope: 'once' };
+        }
+        const rule = this.trustStore.add({ tool: toolName, args, tier, scope: 'PROJECT' });
+        this.history.push({ tool: toolName, decision: 'project-trust', tier, time: Date.now(), rule_id: rule.id });
+        this.approvalLog.append({ tool: toolName, args, tier, decision: 'approve_trusted', scope: 'PROJECT', rule_id: rule.id, prompt });
+        this.emitResolved(approvalId, toolName, true, 'PROJECT', '', context);
+        return { approved: true, tier, scope: 'PROJECT', rule_id: rule.id };
+      }
+
+      case 'allow-type':
+        this.approvedToolTypes.add(toolName);
+        this.history.push({ tool: toolName, decision: 'type-approve', tier, time: Date.now() });
+        this.approvalLog.append({ tool: toolName, args, tier, decision: 'type-approve', scope: 'session', prompt });
+        this.emitResolved(approvalId, toolName, true, 'type', '', context);
+        return { approved: true, tier, scope: 'type' };
+
+      case 'allow-all':
+        this.approveAll = true;
+        this.history.push({ tool: toolName, decision: 'approve-all', tier, time: Date.now() });
+        this.approvalLog.append({ tool: toolName, args, tier, decision: 'approve-all', scope: 'session', prompt });
+        this.emitResolved(approvalId, toolName, true, 'all', '', context);
+        return { approved: true, tier, scope: 'all' };
+
+      case 'reject':
+      default: {
+        const reason = note || 'User stopped the command';
+        this.history.push({ tool: toolName, decision: 'no', tier, time: Date.now(), reason });
+        this.approvalLog.append({ tool: toolName, args, tier, decision: 'reject', scope: 'once', reason, prompt });
+        this._rememberRejection({ tool: toolName, args, tier, decision: 'reject', reason, note });
+        this.emitResolved(approvalId, toolName, false, 'once', reason, context);
+        return { approved: false, tier, reason };
+      }
+    }
+  }
+
+  emitResolved(approvalId, toolName, approved, scope, reason = '', context = {}) {
+    this.emit('agent_approval_resolved', {
+      approval_id: approvalId,
+      tool_id: context.tool_id || context.call_id || context.request_id || '',
+      call_id: context.call_id || context.request_id || context.tool_id || '',
+      tool: toolName,
+      approved,
+      scope,
+      reason,
+    });
+  }
+}
+
+function normalizeDecision(decision = {}) {
+  const value = String(decision.decision || decision.value || '').trim();
+  switch (value) {
+    case 'approve':
+    case 'allow-session':
+    case 'allow-project':
+    case 'allow-type':
+    case 'allow-all':
+    case 'reject':
+      return value;
+    case 'grant':
+      return 'approve';
+    case 'deny':
+    default:
+      return 'reject';
+  }
+}
+
+function promptForBrowser(tool, args, tier, why) {
+  return {
+    title: `Approval · ${String(tier || '').toUpperCase()} · ${tool || 'tool'}`,
+    subject: approvalSubject(tool, args),
+    reason: why || '',
+  };
+}
+
+function approvalSubject(tool, args = {}) {
+  if (tool === 'shell') return args.command || args.cmd || 'shell command';
+  const target = args.path || args.file_path || args.file || args.target || '';
+  return target ? `${tool} ${target}` : String(tool || 'tool');
+}

package/src/local-service/browser.mjs

@@ -0,0 +1,24 @@
+import { spawn } from 'node:child_process';
+
+export function openLocalBrowser(url) {
+  if (!url) return;
+  let command;
+  let args;
+
+  if (process.platform === 'darwin') {
+    command = 'open';
+    args = [url];
+  } else if (process.platform === 'win32') {
+    command = 'cmd';
+    args = ['/c', 'start', '', url];
+  } else {
+    command = 'xdg-open';
+    args = [url];
+  }
+
+  const child = spawn(command, args, {
+    stdio: 'ignore',
+    detached: true,
+  });
+  child.unref();
+}

package/src/local-service/command.mjs

@@ -0,0 +1,155 @@
+/**
+ * CLI command group for Bahulam local workspaces.
+ */
+
+import {
+  createLocalWorkspaceSession,
+  listLocalWorkspaceSessions,
+} from './session-store.mjs';
+import { startLocalWorkspaceService } from './server.mjs';
+import { openLocalBrowser } from './browser.mjs';
+
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+
+export async function runLocalWorkspaceCommand(argv = [], { cwd = process.cwd() } = {}) {
+  const args = parseLocalWorkspaceArgs(argv);
+
+  if (args.help || args.command === 'help') {
+    printLocalWorkspaceHelp();
+    return;
+  }
+
+  if (args.command === 'list' || args.command === 'status') {
+    printLocalWorkspaceSessions();
+    return;
+  }
+
+  if (!['open', 'start', 'serve'].includes(args.command)) {
+    process.stderr.write(`${YELLOW}! Unknown workspace command: ${args.command || '(empty)'}${RESET}\n\n`);
+    printLocalWorkspaceHelp();
+    process.exitCode = 2;
+    return;
+  }
+
+  const { session, token } = createLocalWorkspaceSession({
+    targetPath: args.targetPath || cwd,
+    cwd,
+    kind: args.kind,
+  });
+
+  const service = await startLocalWorkspaceService({
+    session,
+    token,
+    port: args.port,
+  });
+
+  if (args.json) {
+    process.stdout.write(`${JSON.stringify({ ok: true, session, url: service.url, port: service.port }, null, 2)}\n`);
+  } else {
+    process.stderr.write(`\n${BOLD}${CYAN}Bahulam Local Workspace${RESET}\n`);
+    process.stderr.write(`  ${DIM}session${RESET}  ${session.id}\n`);
+    process.stderr.write(`  ${DIM}kind${RESET}     ${session.kind}\n`);
+    process.stderr.write(`  ${DIM}root${RESET}     ${session.root_path}\n`);
+    if (session.focus_path) process.stderr.write(`  ${DIM}focus${RESET}    ${session.focus_path}\n`);
+    process.stderr.write(`  ${DIM}url${RESET}      ${CYAN}${service.url}${RESET}\n\n`);
+  }
+
+  if (args.open) {
+    openLocalBrowser(service.url);
+  }
+
+  process.stderr.write(`${GREEN}ready${RESET} ${DIM}local service is bound to 127.0.0.1:${service.port}. Press Ctrl+C to stop.${RESET}\n`);
+
+  await waitForShutdown(service);
+}
+
+export function parseLocalWorkspaceArgs(argv = []) {
+  const out = {
+    command: argv[0] && !argv[0].startsWith('-') ? argv[0] : 'open',
+    targetPath: null,
+    port: 0,
+    kind: null,
+    open: true,
+    json: false,
+    help: false,
+  };
+
+  const startIndex = out.command === argv[0] ? 1 : 0;
+  for (let i = startIndex; i < argv.length; i++) {
+    const arg = argv[i];
+    switch (arg) {
+      case '--help':
+      case '-h':
+        out.help = true;
+        break;
+      case '--port':
+        out.port = Number(argv[++i]) || 0;
+        break;
+      case '--kind':
+        out.kind = argv[++i] || null;
+        break;
+      case '--no-open':
+        out.open = false;
+        break;
+      case '--json':
+        out.json = true;
+        out.open = false;
+        break;
+      default:
+        if (!arg.startsWith('-') && !out.targetPath) out.targetPath = arg;
+        break;
+    }
+  }
+
+  return out;
+}
+
+function printLocalWorkspaceHelp() {
+  process.stderr.write(`
+  ${BOLD}${CYAN}Bahulam Local Workspace${RESET}
+
+  ${BOLD}Usage:${RESET}
+    bahulam workspace open [path]       Open a local coding/document workspace
+    bahulam workspace start [path]      Alias for open
+    bahulam workspace list              List recent local workspace sessions
+    bahulam local open [path]           Same command group, shorter alias
+
+  ${BOLD}Options:${RESET}
+    --port <n>      Bind a specific localhost port
+    --kind <name>   Override inferred kind: coding, documents, workspace
+    --no-open       Start service without opening the browser
+    --json          Print session JSON and do not open the browser
+
+  ${DIM}The service binds to 127.0.0.1 and grants only the selected file or folder root.${RESET}
+`);
+}
+
+function printLocalWorkspaceSessions() {
+  const sessions = listLocalWorkspaceSessions({ limit: 20 });
+  if (!sessions.length) {
+    process.stderr.write(`${DIM}No local workspace sessions.${RESET}\n`);
+    return;
+  }
+  for (const s of sessions) {
+    process.stderr.write(`${CYAN}${s.id}${RESET}  ${s.kind}  ${s.status}  ${DIM}${s.root_path}${s.focus_path ? `/${s.focus_path}` : ''}${RESET}\n`);
+  }
+}
+
+function waitForShutdown(service) {
+  return new Promise((resolve) => {
+    let done = false;
+    const stop = async () => {
+      if (done) return;
+      done = true;
+      await service.close();
+      resolve();
+    };
+    process.once('SIGINT', stop);
+    process.once('SIGTERM', stop);
+  });
+}