@openagents-org/agent-launcher 0.2.112 → 0.2.114

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openagents-org/agent-launcher",
-  "version": "0.2.112",
+  "version": "0.2.114",
   "description": "OpenAgents Launcher — install, configure, and run AI coding agents from your terminal",
   "main": "src/index.js",
   "bin": {

package/src/adapters/base.js

@@ -53,7 +53,7 @@ class BaseAdapter {
     this._channelQueues = {};
     this._log = (msg) => {
       const ts = new Date().toISOString();
-      console.log(`${ts} INFO adapter: ${msg}`);
+      console.log(`${ts} INFO adapter [${this.agentName}]: ${msg}`);
     };
   }
 
@@ -109,20 +109,15 @@ class BaseAdapter {
   // ------------------------------------------------------------------
 
   async _skipExistingEvents() {
-    try {
-      while (true) {
-        const { cursor } = await this.client.pollPending(
-          this.workspaceId, this.agentName, this.token,
-          { after: this._lastEventId, limit: 200 }
-        );
-        if (!cursor || cursor === this._lastEventId) break;
-        this._lastEventId = cursor;
-      }
-      if (this._lastEventId) {
-        this._log(`Skipped existing events, cursor at ${this._lastEventId}`);
-      }
-    } catch (e) {
-      this._log(`Failed to skip existing events: ${e.message}`);
+    // Jump straight to the head with one server call. Pagination from the
+    // start was slow and brittle: on a busy workspace it could take many
+    // minutes to chew through historical events 200 at a time, leaving the
+    // agent silently behind, and a transient mid-paginate empty response
+    // (e.g. shared-cache race) would strand the cursor at a non-head id.
+    const head = await this.client.getHeadEventId(this.workspaceId, this.token);
+    if (head) {
+      this._lastEventId = head;
+      this._log(`Skipped existing events, cursor at ${head}`);
     }
   }
 

package/src/adapters/claude.js

@@ -390,10 +390,19 @@ class ClaudeAdapter extends BaseAdapter {
     let mcpConfigFile = null;
     let cmd;
 
-    // Clean env
+    // Clean env: strip every CLAUDE_* / AI_AGENT variable inherited from a
+    // parent Claude Code (or Claude Agent SDK) process. If we don't, the
+    // spawned `claude` thinks it's running under an SDK harness and picks
+    // an org-scoped auth path that returns 403 "Account is no longer a
+    // member of the organization" even when the user is logged in fine via
+    // `claude login`. We let the child rediscover auth from
+    // ~/.claude/.credentials.json (or ANTHROPIC_API_KEY if set).
     const cleanEnv = { ...(this.agentEnv || process.env) };
-    delete cleanEnv.CLAUDECODE;
-    delete cleanEnv.CLAUDE_CODE_SESSION;
+    for (const k of Object.keys(cleanEnv)) {
+      if (k.startsWith('CLAUDE_') || k === 'CLAUDECODE' || k === 'AI_AGENT') {
+        delete cleanEnv[k];
+      }
+    }
 
     // Run up to 2 attempts: first with session resume, then fresh if stale session detected
     let _shouldRetry = false;

package/src/cli.js

@@ -117,7 +117,7 @@ async function cmdStatus(connector) {
 
 async function cmdCreate(connector, flags, positional) {
   const name = positional[0];
-  if (!name) { print('Usage: agn create <name> [--type <type>]'); return; }
+  if (!name) { print('Usage: agn create <name> [--type <type>] [--install]'); return; }
   const type = flags.type || 'openclaw';
   const role = flags.role || 'worker';
 
@@ -128,8 +128,12 @@ async function cmdCreate(connector, flags, positional) {
     // Signal daemon to pick up the new agent
     try { connector.sendDaemonCommand('reload'); } catch {}
 
-    // Auto-install if not installed
     if (!connector.isInstalled(type)) {
+      if (!flags.install) {
+        print(`Runtime '${type}' is not installed. Run: agn install ${type}`);
+        return;
+      }
+
       print(`Installing ${type}...`);
       try {
         await connector.install(type);
@@ -513,6 +517,7 @@ Commands:
 
 Options:
   --config <dir>              Config directory (default: ~/.openagents)
+  --install                   Install runtime during create
 `);
 }
 

package/src/config.js

@@ -50,13 +50,14 @@ class Config {
     fs.writeFileSync(this.configFile, serializeYaml(config), 'utf-8');
   }
 
-  addAgent({ name, type, role, path: agentPath }) {
+  addAgent({ name, type, role, path: agentPath, env }) {
     const config = this.load();
     if (config.agents.some((a) => a.name === name)) {
       throw new Error(`Agent '${name}' already exists`);
     }
     const entry = { name, type: type || 'openclaw', role: role || 'worker' };
     if (agentPath) entry.path = agentPath;
+    if (env && Object.keys(env).length > 0) entry.env = env;
     config.agents.push(entry);
     this.save(config);
     return entry;
@@ -80,6 +81,27 @@ class Config {
     return agent;
   }
 
+  updateAgentEnv(name, env) {
+    const config = this.load();
+    const agent = config.agents.find((a) => a.name === name);
+    if (!agent) throw new Error(`Agent '${name}' not found`);
+
+    const merged = { ...(agent.env || {}), ...(env || {}) };
+    const cleaned = {};
+    for (const [key, value] of Object.entries(merged)) {
+      if (value !== null && value !== undefined && value !== '') cleaned[key] = value;
+    }
+
+    if (Object.keys(cleaned).length > 0) {
+      agent.env = cleaned;
+    } else {
+      delete agent.env;
+    }
+
+    this.save(config);
+    return agent.env || {};
+  }
+
   setAgentNetwork(agentName, networkSlug) {
     const config = this.load();
     const agent = config.agents.find((a) => a.name === agentName);
@@ -191,6 +213,43 @@ class Config {
       return { lines: [], size: 0 };
     }
   }
+
+  /**
+   * Remove log entries whose leading timestamp falls within [start, end].
+   * Lines without a parseable timestamp are preserved to avoid deleting
+   * stack traces or continuation lines incorrectly.
+   * @param {Object} opts - { start, end }
+   * @param {string|number|Date} opts.start
+   * @param {string|number|Date} opts.end
+   * @returns {{ removed: number, remaining: number }}
+   */
+  clearLogsInRange(opts = {}) {
+    const start = normalizeTimeValue(opts.start);
+    const end = normalizeTimeValue(opts.end);
+
+    if (!start || !end) {
+      throw new Error('Start time and end time are required');
+    }
+    if (start.getTime() > end.getTime()) {
+      throw new Error('Start time must be before end time');
+    }
+    if (!fs.existsSync(this.logFile)) {
+      return { removed: 0, remaining: 0 };
+    }
+
+    const content = fs.readFileSync(this.logFile, 'utf-8');
+    const hasTrailingNewline = content.endsWith('\n');
+    const allLines = content.split('\n');
+    if (hasTrailingNewline) allLines.pop();
+    const { keptLines, removed } = filterLogsByTimeRange(allLines, start, end);
+
+    const nextContent = keptLines.join('\n') + (hasTrailingNewline && keptLines.length > 0 ? '\n' : '');
+    const tempFile = `${this.logFile}.tmp`;
+    fs.writeFileSync(tempFile, nextContent, 'utf-8');
+    fs.renameSync(tempFile, this.logFile);
+
+    return { removed, remaining: keptLines.length };
+  }
 }
 
 // -- YAML parser (compatible with Python SDK's daemon.yaml format) --
@@ -253,6 +312,115 @@ function parseYaml(text) {
   return result;
 }
 
+function normalizeTimeValue(value) {
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? null : value;
+  }
+  if (typeof value === 'number') {
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  if (typeof value === 'string' && value.trim()) {
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  return null;
+}
+
+function filterLogsByTimeRange(lines, start, end) {
+  const headerTimes = resolveLogHeaderTimestamps(lines, end);
+  let activeRemove = false;
+  let removed = 0;
+  const keptLines = [];
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const headerTime = headerTimes[index];
+    if (headerTime) {
+      const time = headerTime.getTime();
+      activeRemove = time >= start.getTime() && time <= end.getTime();
+    }
+
+    if (activeRemove) {
+      removed += 1;
+    } else {
+      keptLines.push(lines[index]);
+    }
+  }
+
+  return { keptLines, removed };
+}
+
+function resolveLogHeaderTimestamps(lines, referenceTime) {
+  const resolved = new Array(lines.length).fill(null);
+  let currentDay = startOfLocalDay(referenceTime);
+  let lastClockSeconds = null;
+
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const token = parseLogTimestampToken(lines[index]);
+    if (!token) continue;
+
+    if (token.kind === 'iso') {
+      resolved[index] = token.date;
+      currentDay = startOfLocalDay(token.date);
+      lastClockSeconds = (
+        token.date.getHours() * 3600 +
+        token.date.getMinutes() * 60 +
+        token.date.getSeconds()
+      );
+      continue;
+    }
+
+    if (lastClockSeconds !== null && token.seconds > lastClockSeconds) {
+      currentDay = addLocalDays(currentDay, -1);
+    }
+
+    resolved[index] = withLocalClock(currentDay, token.seconds);
+    lastClockSeconds = token.seconds;
+  }
+
+  return resolved;
+}
+
+function parseLogTimestampToken(line) {
+  if (!line) return null;
+
+  const isoMatch = line.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2}))/);
+  if (isoMatch) {
+    const date = new Date(isoMatch[1]);
+    if (!Number.isNaN(date.getTime())) {
+      return { kind: 'iso', date };
+    }
+  }
+
+  const clockMatch = line.match(/^\[(\d{2}):(\d{2}):(\d{2})\]/);
+  if (clockMatch) {
+    return {
+      kind: 'clock',
+      seconds:
+        Number(clockMatch[1]) * 3600 +
+        Number(clockMatch[2]) * 60 +
+        Number(clockMatch[3]),
+    };
+  }
+
+  return null;
+}
+
+function startOfLocalDay(date) {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+}
+
+function addLocalDays(date, days) {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate() + days);
+}
+
+function withLocalClock(day, seconds) {
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const secs = seconds % 60;
+  return new Date(day.getFullYear(), day.getMonth(), day.getDate(), hours, minutes, secs);
+}
+
 function parseYamlValue(val) {
   if (val === '' || val === 'null' || val === '~') return null;
   if (val === 'true') return true;

package/src/daemon.js

@@ -70,7 +70,7 @@ class Daemon {
     this._writeStatus();
     this._cachedAgentNames = new Set(agents.map(a => a.name));
     this._cachedAgentConfigs = {};
-    for (const a of agents) this._cachedAgentConfigs[a.name] = a.network || '';
+    for (const a of agents) this._cachedAgentConfigs[a.name] = this._agentConfigFingerprint(a);
     this._log(`Daemon started with ${agents.length} agent(s)`);
 
     // Block until shutdown
@@ -553,11 +553,19 @@ class Daemon {
   _buildAgentEnv(agentCfg) {
     const type = agentCfg.type || 'openclaw';
     const saved = this.envManager.load(type);
-    const resolved = this.envManager.resolve(type, saved, this.registry);
-    const merged = { ...saved, ...resolved, ...(agentCfg.env || {}) };
+    const mergedSaved = { ...saved, ...(agentCfg.env || {}) };
+    const resolved = this.envManager.resolve(type, mergedSaved, this.registry);
+    const merged = { ...mergedSaved, ...resolved };
     return { ...process.env, ...merged };
   }
 
+  _agentConfigFingerprint(agentCfg) {
+    return JSON.stringify({
+      network: agentCfg.network || '',
+      env: agentCfg.env || {},
+    });
+  }
+
   // ---------------------------------------------------------------------------
   // Internal — agent kill
   // ---------------------------------------------------------------------------
@@ -682,7 +690,7 @@ class Daemon {
     const newAgents = this.config.getAgents();
     const newNames = new Set(newAgents.map(a => a.name));
     const newConfigs = {};
-    for (const a of newAgents) newConfigs[a.name] = a.network || '';
+    for (const a of newAgents) newConfigs[a.name] = this._agentConfigFingerprint(a);
 
     // Stop removed agents
     for (const name of oldNames) {
@@ -698,13 +706,13 @@ class Daemon {
         await this._ensureAdapterCleared(agent.name);
         this._launchAgent(agent);
         this._log(`Reload: started new agent '${agent.name}'`);
-      } else if ((oldConfigs[agent.name] || '') !== (agent.network || '')) {
-        // Network config changed — restart agent
+      } else if ((oldConfigs[agent.name] || '') !== newConfigs[agent.name]) {
+        // Network or env config changed — restart agent
         await this.stopAgent(agent.name);
         this._stoppedAgents.delete(agent.name);
         await this._ensureAdapterCleared(agent.name);
         this._launchAgent(agent);
-        this._log(`Reload: restarted '${agent.name}' (network changed)`);
+        this._log(`Reload: restarted '${agent.name}' (config changed)`);
       }
     }
 

package/src/index.js

@@ -74,22 +74,24 @@ class AgentConnector {
     const agents = this.config.getAgents();
     const networks = this.config.getNetworks();
     return agents.map((a) => {
-      const agentEnv = this.env.load(a.type);
+      const type = a.type || 'openclaw';
+      const typeEnv = this.env.load(type);
       const network = networks.find((n) => n.slug === a.network || n.id === a.network);
       return {
         name: a.name,
-        type: a.type || 'openclaw',
+        type,
         role: a.role || 'worker',
         network: a.network || null,
         networkName: network ? (network.name || network.slug) : null,
         path: a.path || null,
-        env: { ...agentEnv, ...(a.env || {}) },
+        env: { ...typeEnv, ...(a.env || {}) },
+        instanceEnv: { ...(a.env || {}) },
       };
     });
   }
 
-  addAgent({ name, type, role, path }) {
-    this.config.addAgent({ name, type: type || 'openclaw', role: role || 'worker', path });
+  addAgent({ name, type, role, path, env }) {
+    this.config.addAgent({ name, type: type || 'openclaw', role: role || 'worker', path, env });
     return { success: true };
   }
 
@@ -104,6 +106,12 @@ class AgentConnector {
     return this.env.load(agentType);
   }
 
+  getAgentInstanceEnv(agentName) {
+    const agent = this.config.getAgent(agentName);
+    if (!agent) throw new Error(`Agent '${agentName}' not found`);
+    return { ...(agent.env || {}) };
+  }
+
   saveAgentEnv(agentType, env) {
     this.env.save(agentType, env);
     // Configure native auth for agents that need it (e.g. OpenClaw auth-profiles.json)
@@ -117,6 +125,24 @@ class AgentConnector {
     return { success: true };
   }
 
+  saveAgentInstanceEnv(agentName, env) {
+    const agent = this.config.getAgent(agentName);
+    if (!agent) throw new Error(`Agent '${agentName}' not found`);
+    const saved = this.config.updateAgentEnv(agentName, env);
+
+    // Preserve native auth side effects for agents that need them while
+    // keeping the model choice scoped to this individual agent.
+    try {
+      if ((agent.type || 'openclaw') === 'openclaw') {
+        const OpenClawAdapter = require('./adapters/openclaw');
+        const typeEnv = this.env.load(agent.type || 'openclaw');
+        OpenClawAdapter.configureNativeAuth({ ...typeEnv, ...saved });
+      }
+    } catch {}
+
+    return { success: true };
+  }
+
   resolveAgentEnv(agentType, saved) {
     return this.env.resolve(agentType, saved, this.registry);
   }
@@ -199,6 +225,14 @@ class AgentConnector {
     return this.config.getLogs(agentName, lines);
   }
 
+  tailLogs(opts = {}) {
+    return this.config.tailLogs(opts);
+  }
+
+  clearLogsInRange(opts = {}) {
+    return this.config.clearLogsInRange(opts);
+  }
+
   // -- Workspace API --
 
   async createWorkspace(opts) {

package/src/workspace-client.js

@@ -179,6 +179,29 @@ class WorkspaceClient {
     return events.map((e) => this._eventToMessage(e));
   }
 
+  /**
+   * Fetch the latest workspace.message.posted event id (head cursor).
+   * Used by adapters to skip past existing events on join in O(1) instead
+   * of paginating from the start. Returns null if the workspace is empty
+   * or the request fails.
+   */
+  async getHeadEventId(workspaceId, token) {
+    try {
+      const params = new URLSearchParams({
+        network: workspaceId,
+        type: 'workspace.message.posted',
+        sort: 'desc',
+        limit: '1',
+      });
+      const data = await this._get(`/v1/events?${params}`, this._wsHeaders(token));
+      const result = data.data || data;
+      const events = (result && result.events) || [];
+      return events.length > 0 ? (events[0].id || null) : null;
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * Poll for pending messages targeted at an agent via GET /v1/events.
    * Returns { messages, cursor } where cursor is the last event ID.