@bahulam/code 0.1.6 → 0.1.8

package/src/local-service/session-store.mjs

@@ -0,0 +1,221 @@
+/**
+ * Local workspace session store.
+ *
+ * A local service session grants one local directory to the browser shell and
+ * to the remote-agent bridge. If the user opens a single file, the grant root
+ * is the file's parent and focus_path records the selected file.
+ */
+
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import {
+  localServiceSessionDir,
+  localServiceSessionPath,
+  localServiceSessionsRoot,
+} from './paths.mjs';
+import { getLocalMachineIdentity } from './machine.mjs';
+
+const SESSION_PREFIX = 'lws';
+
+export function createLocalAccessToken() {
+  return crypto.randomBytes(24).toString('base64url');
+}
+
+export function hashLocalAccessToken(token) {
+  return crypto.createHash('sha256').update(String(token || '')).digest('hex');
+}
+
+export function verifyLocalAccessToken(session, token) {
+  if (!session?.token_hash || !token) return false;
+  const expected = Buffer.from(session.token_hash, 'hex');
+  const actual = Buffer.from(hashLocalAccessToken(token), 'hex');
+  return expected.length === actual.length && crypto.timingSafeEqual(expected, actual);
+}
+
+export function createLocalWorkspaceSession({
+  targetPath = process.cwd(),
+  cwd = process.cwd(),
+  kind = null,
+  title = null,
+  token = createLocalAccessToken(),
+} = {}) {
+  const grant = resolveGrant(targetPath, cwd);
+  const machine = getLocalMachineIdentity();
+  const now = new Date().toISOString();
+  const session = {
+    id: createSessionId(),
+    product: 'bahulam-local-service',
+    machine_id: machine.id,
+    machine_hostname: machine.hostname,
+    kind: kind || inferSessionKind(grant),
+    title: title || defaultSessionTitle(grant),
+    status: 'active',
+    root_path: grant.rootPath,
+    focus_path: grant.focusPath,
+    resource_type: grant.resourceType,
+    capabilities: inferCapabilities(grant),
+    created_at: now,
+    updated_at: now,
+    token_hash: hashLocalAccessToken(token),
+    remote_bridge: {
+      status: 'cli_relay',
+      contract: 'browser -> local-service -> cli-authenticated remote agent -> local tools',
+    },
+  };
+
+  writeLocalWorkspaceSession(session);
+  return { session: publicSession(session), token };
+}
+
+export function writeLocalWorkspaceSession(session) {
+  if (!session?.id) throw new Error('session.id is required');
+  const dir = localServiceSessionDir(session.id);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  fs.writeFileSync(localServiceSessionPath(session.id), `${JSON.stringify(session, null, 2)}\n`, {
+    mode: 0o600,
+  });
+}
+
+export function loadLocalWorkspaceSession(sessionId) {
+  if (!sessionId) return null;
+  const file = localServiceSessionPath(sessionId);
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+export function listLocalWorkspaceSessions({ limit = 20 } = {}) {
+  let names = [];
+  try {
+    names = fs.readdirSync(localServiceSessionsRoot());
+  } catch {
+    return [];
+  }
+
+  return names
+    .map((name) => loadLocalWorkspaceSession(name))
+    .filter(Boolean)
+    .sort((a, b) => String(b.updated_at || '').localeCompare(String(a.updated_at || '')))
+    .slice(0, limit)
+    .map(publicSession);
+}
+
+export function touchLocalWorkspaceSession(sessionId, patch = {}) {
+  const session = loadLocalWorkspaceSession(sessionId);
+  if (!session) return null;
+  const updated = {
+    ...session,
+    ...patch,
+    updated_at: new Date().toISOString(),
+  };
+  writeLocalWorkspaceSession(updated);
+  return publicSession(updated);
+}
+
+export function publicSession(session) {
+  if (!session) return null;
+  const { token_hash, ...safe } = session;
+  return safe;
+}
+
+export function resolveGrant(inputPath, cwd = process.cwd()) {
+  const resolved = expandPath(inputPath || cwd, cwd);
+  let stat;
+  try {
+    stat = fs.statSync(resolved);
+  } catch {
+    throw new Error(`Path does not exist: ${resolved}`);
+  }
+
+  if (stat.isDirectory()) {
+    return {
+      rootPath: fs.realpathSync(resolved),
+      focusPath: '',
+      resourceType: 'directory',
+    };
+  }
+
+  if (stat.isFile()) {
+    const parent = fs.realpathSync(path.dirname(resolved));
+    return {
+      rootPath: parent,
+      focusPath: path.basename(resolved),
+      resourceType: 'file',
+    };
+  }
+
+  throw new Error(`Path is not a file or directory: ${resolved}`);
+}
+
+export function expandPath(inputPath, cwd = process.cwd()) {
+  let value = String(inputPath || '').trim();
+  if (!value) value = cwd;
+  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+    value = value.slice(1, -1);
+  }
+  if (value === '~') value = os.homedir();
+  else if (value.startsWith('~/')) value = path.join(os.homedir(), value.slice(2));
+  if (!path.isAbsolute(value)) value = path.resolve(cwd, value);
+  return path.normalize(value);
+}
+
+function createSessionId() {
+  const stamp = Date.now().toString(36);
+  const rand = crypto.randomBytes(5).toString('hex');
+  return `${SESSION_PREFIX}_${stamp}_${rand}`;
+}
+
+function defaultSessionTitle(grant) {
+  if (grant.focusPath) return grant.focusPath;
+  return path.basename(grant.rootPath) || grant.rootPath;
+}
+
+function inferSessionKind(grant) {
+  if (grant.resourceType === 'file' && isDocumentLike(grant.focusPath)) return 'documents';
+  if (looksLikeCodeWorkspace(grant.rootPath)) return 'coding';
+  return 'workspace';
+}
+
+function inferCapabilities(grant) {
+  const caps = new Set([
+    'local_files',
+    'local_shell',
+    'browser_workspace',
+    'remote_agent_bridge',
+  ]);
+  if (grant.resourceType === 'file' && isDocumentLike(grant.focusPath)) caps.add('documents');
+  if (looksLikeCodeWorkspace(grant.rootPath)) caps.add('coding');
+  return [...caps];
+}
+
+function isDocumentLike(fileName) {
+  return /\.(?:pdf|docx?|xlsx?|pptx?|csv|tsv|rtf|odt|ods)$/i.test(String(fileName || ''));
+}
+
+function looksLikeCodeWorkspace(rootPath) {
+  const markers = [
+    '.git',
+    'package.json',
+    'pyproject.toml',
+    'requirements.txt',
+    'Cargo.toml',
+    'go.mod',
+    'pom.xml',
+    'Makefile',
+    'Dockerfile',
+    'AGENTS.md',
+    'CLAUDE.md',
+    'BAHULAM.md',
+  ];
+  return markers.some((marker) => {
+    try {
+      return fs.existsSync(path.join(rootPath, marker));
+    } catch {
+      return false;
+    }
+  });
+}

package/src/mcp/client.mjs

@@ -78,7 +78,7 @@ export class McpClient {
         const initResult = await this._request('initialize', {
             protocolVersion: MCP_PROTOCOL_VERSION,
             capabilities: {},
-            clientInfo: { name: 'open-claude-code', version: '2.0.0' },
+            clientInfo: { name: 'bahulam-code', version: '2.0.0' },
         });
 
         this.serverInfo = initResult;
@@ -115,7 +115,7 @@ export class McpClient {
         this.serverInfo = await this.transport.request('initialize', {
             protocolVersion: MCP_PROTOCOL_VERSION,
             capabilities: {},
-            clientInfo: { name: 'open-claude-code', version: '2.0.0' },
+            clientInfo: { name: 'bahulam-code', version: '2.0.0' },
         });
         return this.serverInfo;
     }
@@ -130,7 +130,7 @@ export class McpClient {
         this.serverInfo = await this.transport.request('initialize', {
             protocolVersion: MCP_PROTOCOL_VERSION,
             capabilities: {},
-            clientInfo: { name: 'open-claude-code', version: '2.0.0' },
+            clientInfo: { name: 'bahulam-code', version: '2.0.0' },
         });
         return this.serverInfo;
     }
@@ -139,7 +139,7 @@ export class McpClient {
         const result = await this._transportRequest('initialize', {
             protocolVersion: MCP_PROTOCOL_VERSION,
             capabilities: {},
-            clientInfo: { name: 'open-claude-code', version: '2.0.0' },
+            clientInfo: { name: 'bahulam-code', version: '2.0.0' },
         });
         this.serverInfo = result;
         return result;

package/src/onboarding/preflight.mjs

@@ -4,7 +4,7 @@
  * Prints a non-blocking summary of the runtime environment before the REPL
  * starts so the user can see what is and is not aligned:
  *
- *   🔭 Bahulam Code v2.6.12 · initializing orbit
+ *   🔭 Bahulam Code v0.1.7 · initializing
  *
  *     [✓] Auth token
  *     [✓] OpenRouter key
@@ -334,7 +334,7 @@ function formatRow(check) {
  * collected check results.
  *
  * @param {object} opts
- * @param {object} opts.auth        — TarangAuth instance
+ * @param {object} opts.auth        — BahulamAuth instance
  * @param {string} opts.cwd         — working directory
  * @param {string} opts.version     — package version string
  * @param {boolean} [opts.silent]   — if true, do not write (useful for tests)

package/src/terminal/agents.mjs

@@ -11,7 +11,7 @@
  */
 
 import { c } from './ansi.mjs';
-import { TarangStreamClient } from '../core/stream-client.mjs';
+import { BahulamStreamClient } from '../core/stream-client.mjs';
 
 // ── Agent Definitions ────────────────────────────────────────
 
@@ -296,7 +296,7 @@ export async function runAgentDefinition(agentDefinition, instruction, ctx, sess
     projectRoot: execContext.project_root || null,
   });
 
-  const client = new TarangStreamClient({
+  const client = new BahulamStreamClient({
     baseUrl: creds.backendUrl,
     token: creds.token,
     toolExecutor,

package/src/terminal/analytics.mjs

@@ -202,11 +202,7 @@ export async function runHistoryCommand(args = []) {
   process.stdout.write(formatHistoryReport(history, limit));
 }
 
-// Dashboard removed — now using Bahulam Pulse (pulse/cli.js)
-
-export async function _runDashboardCommand_REMOVED() { /* see pulse/cli.js */ }
-
-export async function _OLD_runDashboardCommand(args = []) {
+export async function runDashboardCommand(args = []) {
   const requestedPort = parseNumber(readOption(args, '--port', '4318'), 4318);
   const host = readOption(args, '--host', '127.0.0.1') || '127.0.0.1';
   const shouldOpen = !hasFlag(args, '--no-open');
@@ -272,7 +268,7 @@ export async function _OLD_runDashboardCommand(args = []) {
   const actualPort = typeof address === 'object' && address ? address.port : requestedPort;
   const url = `http://${host}:${actualPort}`;
 
-  process.stderr.write(`\x1b[36mb0 dashboard\x1b[0m ${url}\n`);
+  process.stderr.write(`\x1b[36mBahulam dashboard\x1b[0m ${url}\n`);
   process.stderr.write(`\x1b[2mReading local analytics from ${getStorePaths().bahulamDir}\x1b[0m\n`);
   process.stderr.write(`\x1b[2mPress Ctrl+C to stop the dashboard server.\x1b[0m\n`);
 

package/src/terminal/ansi.mjs

@@ -2,7 +2,7 @@
  * ANSI Terminal Renderer — cursor control, box drawing, status bars.
  *
  * Color helpers (the `c` object) now route through the semantic palette
- * (`src/ui/palette.mjs`) so the entire CLI honors the Kepler brand and
+ * (`src/ui/palette.mjs`) so the entire CLI honors the Bahulam brand and
  * tier fallbacks (truecolor, ansi256, ansi16, none) without touching
  * each call site. Hot-swap-friendly: external semantics like `c.red`,
  * `c.bold`, `c.cyan` are preserved as the legacy contract; new code
@@ -35,7 +35,7 @@ export const cursor = {
 // ── Colors ──
 // Legacy color names re-mapped onto semantic palette tokens. The CLI's
 // branding is centralized in palette.mjs; this object is preserved only
-// so existing imports keep compiling. Internal Kepler color choices are
+// so existing imports keep compiling. Internal Bahulam color choices are
 // documented next to each mapping for the next code review.
 
 const identity = (s) => String(s ?? '');
@@ -132,12 +132,20 @@ export function inPlace(text) {
   }
   if (text) {
     write(text + '\n');
-    _lastLineCount = text.split('\n').length;
+    _lastLineCount = physicalLineCount(text);
   } else {
     _lastLineCount = 0;
   }
 }
 
+function physicalLineCount(text) {
+  const width = Math.max(1, process.stderr.columns || process.stdout.columns || 80);
+  return String(text || '').split('\n').reduce((total, line) => {
+    const cells = visibleWidth(line);
+    return total + Math.max(1, Math.ceil(cells / width));
+  }, 0);
+}
+
 // ── Status Bar (persistent bottom) ──
 
 export function statusBar(parts) {

package/src/terminal/main.mjs

@@ -8,6 +8,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { startTerminalRepl } from './repl.mjs';
 import {
+  runDashboardCommand,
   runSessionsCommand,
   runStatsCommand,
   runHistoryCommand,
@@ -15,7 +16,7 @@ import {
 import { parseArgs } from '../config/cli-args.mjs';
 import * as telemetry from '../telemetry/index.mjs';
 import { bahulamHome } from '../core/paths.mjs';
-import { TarangAuth as Auth } from '../auth/tarang-auth.mjs';
+import { BahulamAuth as Auth } from '../auth/bahulam-auth.mjs';
 
 // ── Subcommands ──
 
@@ -123,16 +124,29 @@ async function main() {
   } catch {}
 
   if (subcommand === 'dashboard') {
-    // Launch Bahulam Pulse Next.js dashboard
-    const { spawn } = await import('node:child_process');
-    const { fileURLToPath } = await import('node:url');
-    const path = await import('node:path');
-    const cliPath = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'pulse', 'cli.js');
-    const child = spawn(process.execPath, [cliPath, ...subcommandArgs], {
-      stdio: 'inherit',
-      env: process.env,
-    });
-    child.on('exit', (code) => process.exit(code ?? 0));
+    // Try to open the live daemon's HTTP dashboard first
+    try {
+      const { findSessionForCwd } = await import('../daemon/daemonize.mjs');
+      const sid = await findSessionForCwd(process.cwd());
+      if (sid) {
+        const { daemonSessionDir } = await import('../core/paths.mjs');
+        const metaPath = path.join(daemonSessionDir(sid), 'meta.json');
+        if (fs.existsSync(metaPath)) {
+          const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+          if (meta.dashboard_url) {
+            process.stderr.write(`\x1b[2mOpening dashboard for session ${sid}…\x1b[0m\n`);
+            const { execSync } = await import('node:child_process');
+            const cmd = process.platform === 'darwin' ? 'open'
+                      : process.platform === 'win32' ? 'start'
+                      : 'xdg-open';
+            execSync(`${cmd} "${meta.dashboard_url}"`, { stdio: 'ignore', timeout: 3000 });
+            process.exit(0);
+            return;
+          }
+        }
+      }
+    } catch {}
+    await runDashboardCommand(subcommandArgs);
     return;
   }
 
@@ -169,8 +183,8 @@ async function main() {
   }
 
   if (subcommand === 'login') {
-    const { TarangAuth } = await import('../auth/tarang-auth.mjs');
-    const auth = new TarangAuth();
+    const { BahulamAuth } = await import('../auth/bahulam-auth.mjs');
+    const auth = new BahulamAuth();
     try {
       telemetry.track('login_shown', { method: 'cli_subcommand' });
       await auth.login();
@@ -184,8 +198,8 @@ async function main() {
   }
 
   if (subcommand === 'logout') {
-    const { TarangAuth } = await import('../auth/tarang-auth.mjs');
-    const auth = new TarangAuth();
+    const { BahulamAuth } = await import('../auth/bahulam-auth.mjs');
+    const auth = new BahulamAuth();
     const success = auth.logout();
     if (success) {
       process.stderr.write('\x1b[32m✓ Signed out. Credentials cleared.\x1b[0m\n');
@@ -227,6 +241,7 @@ async function main() {
                               Attach an image via the vision analysis pipeline
     bahulam --resume               Resume last conversation
     bahulam dashboard              Open analytics dashboard
+    bahulam workspace open [path]  Open a local browser workspace
     bahulam login                  Sign in via browser
     bahulam logout                 Sign out and clear credentials
     bahulam init                   Scaffold .bahulam config, memory, hooks, tasks
@@ -240,6 +255,11 @@ async function main() {
     bahulam remote enable      Enable relay connection
     bahulam remote disable     Disable relay connection (kill switch)
 
+  \x1b[1mLocal Workspaces:\x1b[0m
+    bahulam workspace open [path]  Start localhost workspace service
+    bahulam workspace list         List recent local workspace sessions
+    bahulam local open [path]      Alias for workspace open
+
   \x1b[1mAnalytics:\x1b[0m
     bahulam sessions               List recent local sessions
     bahulam stats                  Show aggregate local session stats
@@ -261,7 +281,7 @@ async function main() {
     /new                    Start a new session
     /clear                  Clear conversation history
     /safety                 Show safety guardrail status
-    /revoke                 Revoke auto-approvals
+    /approvals clear        Revoke all session auto-approvals
     /explore <query>        Spawn read-only codebase explorer
     /review <query>         Spawn code review agent
     /architect <query>      Spawn architecture planning agent
@@ -286,7 +306,7 @@ async function main() {
     KEPLER_RECONNECT_MAX_ELAPSED_MS
                             Max reconnect window for dropped streams
     BAHULAM_TTY_MODE=stable Scrollback-safe transcript if fixed dock redraws leak
-    KEPLER_BLOCK_SEPARATOR  Tool/content separator: space, dotted, or off
+    BAHULAM_BLOCK_SEPARATOR Tool/content separator: space, dotted, or off
 
   \x1b[2mDocs: https://bahulam.ai\x1b[0m
 `);
@@ -331,6 +351,12 @@ async function main() {
     return;
   }
 
+  if (subcommand === 'workspace' || subcommand === 'workspaces' || subcommand === 'local') {
+    const { runLocalWorkspaceCommand } = await import('../local-service/command.mjs');
+    await runLocalWorkspaceCommand(subcommandArgs, { cwd: process.cwd() });
+    return;
+  }
+
   //  auto-daemon spawn.
   //   bahulam daemonize [prompt]  → fork a detached bahulam child with
   //   the socket server up. Parent waits briefly for the child's session

package/src/terminal/model-catalog-display.mjs

@@ -0,0 +1,111 @@
+import { c } from './ansi.mjs';
+
+export const MODEL_CATEGORY_ORDER = [
+  'text',
+  'image_analysis',
+  'image_generation',
+  'image',
+  'multimodal',
+  'embedding',
+  'audio',
+  'video',
+  'other',
+];
+
+export function modelCategory(model) {
+  const category = String(model?.category || 'text').trim().toLowerCase();
+  return category === 'chat' ? 'text' : (category || 'text');
+}
+
+export function isImageGenerationModel(model) {
+  const text = `${model?.id || ''} ${model?.label || ''}`.toLowerCase();
+  return (
+    text.includes('image generation') ||
+    text.includes('generate image') ||
+    text.includes('gemini-3-pro-image') ||
+    text.includes('nano banana')
+  );
+}
+
+export function modelDisplayCategory(model) {
+  const category = modelCategory(model);
+  if (category === 'image') {
+    return isImageGenerationModel(model) ? 'image_generation' : 'image_analysis';
+  }
+  return category;
+}
+
+export function normalizeCatalogCategory(value) {
+  const raw = String(value || '').trim().toLowerCase();
+  if (!raw) return null;
+  if (raw === 'chat') return 'text';
+  if (raw === 'image-analysis' || raw === 'vision') return 'image_analysis';
+  if (raw === 'image-generation' || raw === 'image-gen') return 'image_generation';
+  return raw;
+}
+
+export function modelMatchesCatalogFilter(model, filter) {
+  if (!filter) return true;
+  if (filter === 'image') return modelCategory(model) === 'image';
+  return modelDisplayCategory(model) === filter || modelCategory(model) === filter;
+}
+
+export function modelCategoryLabel(category, { plural = false } = {}) {
+  const labels = {
+    text: 'text',
+    image: 'image',
+    image_analysis: 'image analysis',
+    image_generation: 'image generation',
+    embedding: 'embedding',
+    audio: 'audio',
+    video: 'video',
+    other: 'other',
+    multimodal: 'multimodal',
+  };
+  const base = labels[String(category || '').trim().toLowerCase()] || 'other';
+  return plural ? `${base} models` : base;
+}
+
+function categoryColor(category) {
+  switch (String(category || '').trim().toLowerCase()) {
+    case 'text':
+      return c.brand;
+    case 'image':
+    case 'image_analysis':
+      return c.magenta;
+    case 'image_generation':
+      return c.yellow;
+    case 'multimodal':
+      return c.cyanBold;
+    case 'embedding':
+      return c.green;
+    case 'audio':
+      return c.cyanRegular;
+    case 'video':
+      return c.red;
+    default:
+      return c.gray;
+  }
+}
+
+export function formatCategoryBadge(category, { plural = false } = {}) {
+  const normalized = String(category || 'text').trim().toLowerCase() || 'text';
+  return categoryColor(normalized)(`[${modelCategoryLabel(normalized, { plural })}]`);
+}
+
+export function formatCategoryHeading(category, count = null) {
+  const label = modelCategoryLabel(category, { plural: true });
+  const countText = Number.isFinite(Number(count)) ? ` ${c.dim(`(${count})`)}` : '';
+  return `${categoryColor(category)(c.bold(label))}${countText}`;
+}
+
+export function cacheProfileLabel(value) {
+  if (!value) return '';
+  try {
+    const parsed = typeof value === 'string' ? JSON.parse(value) : value;
+    if (parsed?.type === 'prefix_hash') return 'prefix cache';
+  } catch {
+    // Fall through to the generic cache hint.
+  }
+  return 'cache';
+}

package/src/terminal/repl-format.mjs

@@ -11,6 +11,8 @@ import * as path from 'node:path';
 import { c, stripAnsi, formatElapsed, inPlace } from './ansi.mjs';
 import * as rqueue from '../ui/render-queue.mjs';
 
+const ANSI_RESET = '\x1b[0m';
+
 // Transient one-line status writer that is safe under the render queue.
 // Raw inPlace() writes get REDIRECTED into transcript content when the
 // queue is active (cursor codes stripped) — that leaked one line per
@@ -102,7 +104,7 @@ export function fitAnsiLine(text, maxColumns) {
     out += value[i];
     visible++;
   }
-  return `${out}${c.dim('…')}`;
+  return `${out}${ANSI_RESET}${c.dim('…')}`;
 }
 
 // ── PRD-068 §5.14 helpers ────────────────────────────────────────────
@@ -284,6 +286,7 @@ export function normalizeResumableSession(s) {
     resumeSummary: s.resumeSummary || null,    // latest resume_summary checkpoint metadata
     models: Array.isArray(s.models) ? s.models : [],
     modelLimits: s.modelLimits && typeof s.modelLimits === 'object' ? s.modelLimits : {},
+    subAgentModels: s.subAgentModels && typeof s.subAgentModels === 'object' ? s.subAgentModels : {},
     costUsd: typeof s.costUsd === 'number' ? s.costUsd : 0,
     partial: !!s.partial,                      // true if the transcript file was partially malformed
     source: 'transcript',