@inneranimalmedia/agentsam-sdk 2.6.0 → 2.6.2

package/test/smoke.mjs

@@ -56,6 +56,7 @@ assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/deploy'));
 assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/db'));
 assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/agent'));
 assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/model'));
+assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/providers'));
 assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/reasoning'));
 assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/fast'));
 assert.deepEqual(
@@ -65,7 +66,7 @@ assert.deepEqual(
 );
 
 printContextSummary({
-  iam: { ready: true, source: 'sdk-key', detail: 'AGENTSAM_SDK_KEY' },
+  iam: { ready: true, source: 'api_key', detail: 'AGENTSAM_API_KEY' },
   gcp: { source: 'vm-metadata', email: 'execos@project.iam.gserviceaccount.com' },
   gcp_vm: true,
   github: { source: 'gh-cli', account: 'user@example.com' },

package/test/terminal/local-pty.mock.test.mjs

@@ -0,0 +1,151 @@
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+import { pathToFileURL } from 'node:url';
+import {
+  attachLocalPtySession,
+  ensureNodePtySpawnHelperExecutable,
+  startLocalPtyServer,
+} from '../../src/local-pty/server.js';
+
+function fakeTransports() {
+  const writes = [];
+  const resizes = [];
+  let killed = 0;
+  let dataHandler = null;
+  let exitHandler = null;
+
+  const pty = {
+    spawn(shell, args, options) {
+      assert.equal(Array.isArray(args), true);
+      assert.equal(options.env.AGENTSAM_LOCAL_PTY, '1');
+      return {
+        write(value) { writes.push(value); },
+        resize(cols, rows) { resizes.push([cols, rows]); },
+        kill() { killed += 1; },
+        onData(fn) { dataHandler = fn; },
+        onExit(fn) { exitHandler = fn; },
+      };
+    },
+  };
+
+  class FakeWs extends EventEmitter {
+    OPEN = 1;
+    readyState = 1;
+    sent = [];
+    send(value) { this.sent.push(String(value)); }
+    close() {
+      if (this.readyState !== this.OPEN) return;
+      this.readyState = 3;
+      this.emit('close');
+    }
+  }
+
+  const ws = new FakeWs();
+  return {
+    pty,
+    ws,
+    writes,
+    resizes,
+    killed: () => killed,
+    emitData(value) { dataHandler?.(value); },
+    emitExit() { exitHandler?.(); },
+  };
+}
+
+test('macOS node-pty helper is made executable before runtime import', (t) => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-node-pty-helper-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const libDir = path.join(root, 'lib');
+  const helperDir = path.join(root, 'prebuilds', 'darwin-arm64');
+  fs.mkdirSync(libDir, { recursive: true });
+  fs.mkdirSync(helperDir, { recursive: true });
+  fs.writeFileSync(path.join(libDir, 'index.js'), '');
+  const helper = path.join(helperDir, 'spawn-helper');
+  fs.writeFileSync(helper, 'fake');
+  fs.chmodSync(helper, 0o644);
+
+  const result = ensureNodePtySpawnHelperExecutable({
+    platform: 'darwin',
+    arch: 'arm64',
+    resolveModule: () => pathToFileURL(path.join(libDir, 'index.js')).href,
+  });
+
+  assert.equal(result.checked, true);
+  assert.equal(result.changed, true);
+  assert.equal(result.path, helper);
+  assert.notEqual(fs.statSync(helper).mode & 0o111, 0);
+
+  const second = ensureNodePtySpawnHelperExecutable({
+    platform: 'darwin',
+    arch: 'arm64',
+    resolveModule: () => pathToFileURL(path.join(libDir, 'index.js')).href,
+  });
+  assert.equal(second.changed, false);
+});
+
+test('local PTY wire protocol is release-testable entirely in memory', () => {
+  const transport = fakeTransports();
+  const session = attachLocalPtySession({
+    ws: transport.ws,
+    pty: transport.pty,
+    shell: '/bin/test-shell',
+    cwd: '/tmp/test-project',
+    cols: 80,
+    rows: 24,
+    env: {},
+    sessionId: 'local_test',
+  });
+
+  assert.equal(session.session_id, 'local_test');
+  assert.deepEqual(JSON.parse(transport.ws.sent[0]), {
+    type: 'session_id',
+    session_id: 'local_test',
+  });
+
+  transport.ws.emit('message', Buffer.from(JSON.stringify({ type: 'resize', cols: 120, rows: 40 })));
+  transport.ws.emit('message', Buffer.from(JSON.stringify({ type: 'slash', line: '/pwd' })));
+  transport.ws.emit('message', Buffer.from('raw input'));
+
+  assert.deepEqual(transport.resizes, [[120, 40]]);
+  assert.deepEqual(transport.writes, ['/pwd\r', 'raw input']);
+
+  transport.emitData('terminal output');
+  assert.equal(transport.ws.sent.at(-1), 'terminal output');
+
+  transport.ws.close();
+  assert.equal(transport.killed(), 1);
+
+  // Cleanup is idempotent even when transport error/close paths race.
+  transport.ws.emit('error', new Error('synthetic transport close'));
+  session.cleanup();
+  assert.equal(transport.killed(), 1);
+});
+
+test('local PTY server health check uses an ephemeral local port and no ExecOS tunnel', async () => {
+  const transport = fakeTransports();
+  const server = await startLocalPtyServer({
+    cwd: process.cwd(),
+    host: '127.0.0.1',
+    port: 0,
+    pty: transport.pty,
+  });
+
+  try {
+    const health = await fetch(server.healthUrl);
+    assert.equal(health.status, 200);
+    const body = await health.json();
+    assert.equal(body.ok, true);
+    assert.equal(body.service, 'agentsam-local-pty');
+    assert.equal(body.port, server.port);
+    assert.equal(server.port > 0, true);
+  } finally {
+    await server.close();
+  }
+
+  // No WebSocket session was opened, so the PTY process was never spawned.
+  assert.equal(transport.killed(), 0);
+});

package/test/whoami-resume.test.mjs

@@ -14,9 +14,9 @@ function tempHome(t) {
   return home;
 }
 
-test('whoami validates persisted IAM identity while never returning the SDK or provider secret', async t => {
+test('whoami validates persisted IAM browser identity while never returning account or provider secrets', async t => {
   const home = tempHome(t);
-  saveAccountSession({ access_token: 'sdk_do_not_print', user_id: 'au_local' }, { home });
+  saveAccountSession({ access_token: 'browser_session_do_not_print', user_id: 'au_local' }, { home });
   const envDir = path.join(home, '.agentsam', 'env.d');
   fs.mkdirSync(envDir, { recursive: true });
   const openaiFile = path.join(envDir, 'openai.env');
@@ -26,16 +26,17 @@ test('whoami validates persisted IAM identity while never returning the SDK or p
   const status = await collectWhoami({
     env: {}, home,
     contextLoader: async token => {
-      assert.equal(token, 'sdk_do_not_print');
+      assert.equal(token, 'browser_session_do_not_print');
       return { user_id: 'au_server', account_id: 'acct_server', email: 'dev@example.test', cloudflare: { ok: true }, byok: { openai: { configured: true, masked: 'secret' } } };
     },
   });
   assert.equal(status.authenticated, true);
   assert.equal(status.identity.account_id, 'acct_server');
-  assert.equal(status.sdk_credential.source, 'agentsam_account_session');
+  assert.equal(status.active_auth.source, 'agentsam_browser_oauth');
+  assert.equal(status.active_auth.kind, 'browser_oauth');
   assert.equal(status.provider_credentials.find(row => row.provider === 'openai').configured, true);
   const serialized = JSON.stringify(status);
-  assert.doesNotMatch(serialized, /sdk_do_not_print|sk-never-print-this|masked/);
+  assert.doesNotMatch(serialized, /browser_session_do_not_print|sk-never-print-this|masked/);
 });
 
 test('resume restores saved cwd and session through the canonical shell runtime', async t => {

package/src/lib/prompt-byok.js

@@ -1,57 +0,0 @@
-/**
- * Optional BYOK key paste during SDK init → CORE user_api_keys.
- */
-import { getJson, postJson } from './core-client.js';
-
-const PROVIDERS = [
-  { id: 'openai', label: 'OpenAI' },
-  { id: 'anthropic', label: 'Anthropic' },
-];
-
-/**
- * @param {string} token SDK bearer
- * @param {{ ask: (q: string) => Promise<string> } | null} prompt
- */
-export async function promptOptionalByokKeys(token, prompt) {
-  if (!token || !prompt) return;
-
-  let ctx;
-  try {
-    ctx = await getJson('/api/sdk/context', token);
-  } catch {
-    console.log('\n  ⚠ Could not load BYOK status — skip key paste or add keys in Dashboard → Settings → Keys\n');
-    return;
-  }
-
-  const byok = ctx?.byok || {};
-  console.log('\n  Provider keys (BYOK — optional, stored in YOUR IAM account):\n');
-
-  for (const p of PROVIDERS) {
-    const slot = byok[p.id];
-    if (slot?.configured) {
-      console.log(`    ${p.label.padEnd(12)} ✓ connected ${slot.masked || ''}`);
-      continue;
-    }
-
-    const ans = await prompt.ask(`    ${p.label} API key (Enter to skip): `);
-    const key = ans.trim();
-    if (!key) continue;
-
-    try {
-      await postJson(
-        '/api/sdk/keys',
-        {
-          provider: p.id,
-          api_key: key,
-          label: `${p.label} (SDK init)`,
-          validate: true,
-        },
-        token,
-      );
-      console.log(`    ${p.label.padEnd(12)} ✓ saved to IAM BYOK`);
-    } catch (e) {
-      console.log(`    ${p.label.padEnd(12)} ✗ ${e?.message || 'save failed'}`);
-    }
-  }
-  console.log('');
-}

package/src/lib/save-sdk-token.js

@@ -1,19 +0,0 @@
-/**
- * Persist SDK session token locally for repeat inits (user's machine only).
- */
-import fs from 'fs';
-import path from 'path';
-
-export function saveSdkTokenHint(cwd, token) {
-  const t = String(token || '').trim();
-  if (!t || !t.startsWith('sdk_')) return null;
-  const dir = path.join(path.resolve(cwd), '.agentsam');
-  fs.mkdirSync(dir, { recursive: true });
-  const hintPath = path.join(dir, 'credentials.env.example');
-  const content = `# Agent Sam SDK — add to your shell profile (optional)
-export AGENTSAM_SDK_KEY=${t}
-export USER_GCP_PROJECT=YOUR_GCP_PROJECT_ID
-`;
-  fs.writeFileSync(hintPath, content, 'utf8');
-  return hintPath;
-}