@inneranimalmedia/agentsam-sdk 2.6.4 → 2.6.7

package/test/repository-snapshot-view.test.mjs

@@ -25,13 +25,13 @@ function snapshot() {
       files: [
         {
           path: 'packages/identity/src/core/accounts.js', type: 'file', size: 213, mode: 420, hash: `sha256:${'a'.repeat(64)}`,
-          package: '@inneranimalmedia/agentsam-sdk-identity', package_root: 'packages/identity', system: 'identity',
+          package: '@inneranimalmedia/agentsam-identity', package_root: 'packages/identity', system: 'identity',
           category: 'accounts', layer: 'core', kind: 'source', language: 'javascript', role: 'business-logic', execution_domain: 'unknown',
           tags: ['account-scoped', 'authentication'], symbols: ['accountLinkingNotConfigured'], imports: [],
         },
         {
           path: 'packages/identity/src/oauth/login.js', type: 'file', size: 300, mode: 420, hash: `sha256:${'b'.repeat(64)}`,
-          package: '@inneranimalmedia/agentsam-sdk-identity', package_root: 'packages/identity', system: 'identity',
+          package: '@inneranimalmedia/agentsam-identity', package_root: 'packages/identity', system: 'identity',
           category: 'login', layer: 'oauth', kind: 'source', language: 'javascript', role: 'business-logic', execution_domain: 'unknown',
           tags: ['authentication'], symbols: ['login'], imports: ['./accounts.js'],
         },

package/test/security.test.mjs

@@ -166,6 +166,29 @@ test('repair retains failed candidates and never labels failed verification as f
   assert.equal(g('status','--porcelain'),'');
   assert.match(result.reason,/command failed/);
 });
+test('exact release candidate tarball may be scanned without weakening normal local dependency rejection', t => {
+  const f = fixture(t);
+  f.pkg.dependencies['@inneranimalmedia/agentsam-sdk'] = 'file:./candidate.tgz';
+  f.lock.packages[''].dependencies = { ...f.pkg.dependencies };
+  f.lock.packages['node_modules/@inneranimalmedia/agentsam-sdk'] = {
+    name: '@inneranimalmedia/agentsam-sdk',
+    version: '2.6.5',
+    resolved: 'file:./candidate.tgz',
+  };
+  f.write();
+  const strict = collectNpmDependencies(f.root);
+  assert.ok(strict.issues.some(issue => issue.includes('node_modules/@inneranimalmedia/agentsam-sdk')));
+  const candidate = collectNpmDependencies(f.root, {
+    releaseCandidate: {
+      name: '@inneranimalmedia/agentsam-sdk',
+      version: '2.6.5',
+      location: 'node_modules/@inneranimalmedia/agentsam-sdk',
+    },
+  });
+  assert.equal(candidate.issues.some(issue => issue.includes('node_modules/@inneranimalmedia/agentsam-sdk')), false);
+  assert.ok(candidate.dependencies.some(dep => dep.name === '@inneranimalmedia/agentsam-sdk' && dep.version === '2.6.5'));
+});
+
 test('workspace stale locks and external links are incomplete', async t => {
   const f=fixture(t);
   f.lock.packages['node_modules/external']={link:true,resolved:'../elsewhere'};
@@ -227,3 +250,17 @@ test('browser env and server-runtime imports are derived from syntax rather than
   assert.ok(kinds.has('browser-public-secret-name'));
   assert.ok(kinds.has('browser-private-env-access'));
 });
+
+test('security run never loads heavy scan stack when child command fails', async t => {
+  const f = fixture(t);
+  const result = spawnSync(process.execPath, [cli, 'run', '--path', f.root, '--json', '--', process.execPath, '-e', 'console.error("install boom"); process.exit(17)'], { encoding: 'utf8' });
+  assert.equal(result.status, 1);
+  const report = JSON.parse(result.stdout);
+  assert.equal(report.status, 'command-failed');
+  assert.equal(report.ok, false);
+  assert.equal(report.command_exit_code, 17);
+  assert.match(report.stderr || report.log || '', /install boom/);
+  assert.equal(report.error, undefined);
+  assert.ok(!JSON.stringify(report).includes('ERR_MODULE_NOT_FOUND'));
+  assert.ok(!JSON.stringify(report).includes('typescript'));
+});

package/test/setup-planner.test.mjs

@@ -0,0 +1,74 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { buildSetupPlan, renderSetupPlan } from '../src/lib/setup/planner.js';
+import { listCapabilityRecipes, getCapabilityRecipe } from '../src/lib/setup/recipes.js';
+import { runSetup } from '../src/commands/setup.js';
+
+test('recipes include image.vectorize and google.cloud', () => {
+  const ids = listCapabilityRecipes().map((r) => r.id);
+  assert.ok(ids.includes('image.vectorize'));
+  assert.ok(ids.includes('google.cloud'));
+  assert.equal(getCapabilityRecipe('image.vectorize').installPlans.darwin.provider, 'homebrew');
+});
+
+test('setup plan is satisfied when image tools already installed', async () => {
+  const environment = {
+    hostname: 'Test-Host',
+    host_label: 'Mac',
+    platform: 'darwin',
+    arch: 'arm64',
+    tools: {},
+  };
+  const plan = await buildSetupPlan({
+    environment,
+    capabilityIds: ['image.vectorize'],
+  });
+  assert.equal(plan.schema_version, 'agentsam-setup-plan-v1');
+  const image = plan.capabilities.find((c) => c.id === 'image.vectorize');
+  assert.ok(image);
+  // This machine already has brew imagemagick/potrace from logo work — plan should reflect detect().
+  if (image.detected?.ok) {
+    assert.equal(plan.would_install.length, 0);
+  } else {
+    assert.ok(plan.would_install.length >= 1);
+    assert.equal(plan.would_install[0].provider, 'homebrew');
+  }
+  const text = renderSetupPlan(plan);
+  assert.match(text, /Agent Sam Setup|Vector image/);
+});
+
+test('renderSetupPlan shows would-install block for synthetic missing tools', () => {
+  const text = renderSetupPlan({
+    hostname: 'Test-Host',
+    host_label: 'Mac',
+    platform: 'darwin',
+    capabilities: [
+      {
+        id: 'image.vectorize',
+        displayName: 'Vector image tooling',
+        detected: { ok: false, detail: 'missing' },
+      },
+    ],
+    would_install: [
+      { provider: 'homebrew', packages: ['imagemagick', 'potrace'], capability: 'image.vectorize' },
+    ],
+    providers: ['homebrew'],
+    mutations: [],
+    trust_notes: ['no silent trust'],
+  });
+  assert.match(text, /Would install/);
+  assert.match(text, /imagemagick/);
+  assert.match(text, /homebrew/);
+});
+
+test('setup --list and --dry-run exit 0', async () => {
+  let out = '';
+  const write = (s) => {
+    out += s;
+  };
+  assert.equal(await runSetup(['--list'], { write, env: process.env }), 0);
+  assert.match(out, /image\.vectorize/);
+  out = '';
+  assert.equal(await runSetup(['image.vectorize', '--dry-run'], { write, env: process.env }), 0);
+  assert.match(out, /Environment|Agent Sam Setup/);
+});

package/test/setup-runtime.test.mjs

@@ -0,0 +1,51 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import os from 'node:os';
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  RUNTIME_PROFILES,
+  planRuntimeSetup,
+  writeRuntimePlanReceipt,
+  renderRuntimePlan,
+} from '../src/lib/setup/runtime.js';
+
+describe('agentsam setup runtime', () => {
+  it('exposes five goal profiles', () => {
+    assert.equal(RUNTIME_PROFILES.length, 5);
+    assert.ok(RUNTIME_PROFILES.some((p) => p.id === 'my_computer'));
+    assert.ok(RUNTIME_PROFILES.every((p) => p.runtime_adapter));
+  });
+
+  it('plans with GOAP and writes receipt under tmp home', async () => {
+    const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-runtime-'));
+    const plan = await planRuntimeSetup({
+      home,
+      facts: {
+        schema: 'agentsam.runtime-setup.v1',
+        protocol: 'agentsam.runtime.v1',
+        host: { hostname: 'test', platform: 'darwin', arch: 'arm64', label: 'Mac' },
+        tools: { docker: true, gcloud: false, wrangler: true, go: true },
+        agentsamd: { binary: null, installed: false, prior_receipt: null },
+        available_capabilities: {
+          exec: true,
+          pty: true,
+          filesystem: true,
+          process: true,
+          git: true,
+          docker: true,
+          ports: true,
+          persistent_filesystem: true,
+        },
+      },
+    });
+    assert.ok(plan.recommended);
+    assert.equal(plan.recommended.profile.id, 'my_computer');
+    assert.ok(plan.recommended.goap.action_ids.includes('ensure_agentsamd_binary'));
+    const receipt = writeRuntimePlanReceipt(plan, home);
+    assert.ok(fs.existsSync(receipt));
+    const text = renderRuntimePlan(plan);
+    assert.match(text, /setup runtime/);
+    assert.match(text, /My Computer/);
+  });
+});

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

@@ -139,7 +139,9 @@ test('local PTY server health check uses an ephemeral local port and no ExecOS t
     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.service, 'agentsam.local.runtime');
+    assert.equal(body.plane, 'local');
+    assert.equal(body.service_legacy, 'agentsam-local-pty');
     assert.equal(body.port, server.port);
     assert.equal(server.port > 0, true);
   } finally {

package/test/terminal-machine-identity.test.mjs

@@ -0,0 +1,88 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { runTerminal } from '../src/commands/terminal.js';
+import { normalizeTerminalArch, normalizeTerminalPlatform } from '../src/lib/terminal/machine-identity.js';
+
+test('identity command prints this host vocabulary without calling the network', async () => {
+  const lines = [];
+  const result = await runTerminal(['identity'], {
+    write: (line) => lines.push(line),
+    collectIdentity: async () => ({
+      hostname: 'dev-machine',
+      platform: 'macos',
+      arch: 'arm64',
+      model: 'Mac16,2',
+    }),
+    postJson: async () => {
+      throw new Error('identity must not post');
+    },
+  });
+  assert.equal(result.ok, true);
+  assert.equal(result.arch, 'arm64');
+  assert.match(lines.join('\n'), /arch:\s+arm64/);
+  assert.match(lines.join('\n'), /hw_model:\s+Mac16,2/);
+});
+
+test('enroll without a target does not mint a token', async () => {
+  let posted = false;
+  const result = await runTerminal(['enroll', '--json'], {
+    write: () => {},
+    collectIdentity: async () => ({ hostname: 'box', platform: 'linux', arch: 'x86_64', model: 'container' }),
+    postJson: async () => { posted = true; return {}; },
+  });
+  assert.equal(posted, false);
+  assert.equal(result.enrolled, false);
+  assert.equal(result.arch, 'x86_64');
+});
+
+test('enroll posts canonical identity for the instance the caller named', async () => {
+  let body = null;
+  const result = await runTerminal(['enroll', '--instance', 'tinst_sams_imac', '--json'], {
+    write: () => {},
+    collectIdentity: async () => ({
+      hostname: 'dev-machine',
+      platform: 'macos',
+      arch: 'arm64',
+      model: 'Mac16,2',
+    }),
+    postJson: async (_path, posted) => {
+      body = posted;
+      return { instance_id: 'tinst_sams_imac', connection_id: 'conn_mac_local', enrollment_token_id: 'tenr_test', enrollment_token: 'tok_test' };
+    },
+  });
+  assert.equal(result.enrolled, true);
+  assert.equal(body.instance_id, 'tinst_sams_imac');
+  assert.equal(body.platform, 'macos');
+  assert.equal(body.arch, 'arm64');
+  assert.equal(body.hw_model, 'Mac16,2');
+  assert.equal(body.kind, 'local_device');
+});
+
+test('enroll --pair consumes the token via ExecOS enroll (writes AGENTSAM_BRIDGE_KEY)', async () => {
+  let pairedToken = null;
+  const result = await runTerminal(['enroll', '--instance', 'tinst_sams_imac', '--pair', '--json'], {
+    write: () => {},
+    collectIdentity: async () => ({ hostname: 'box', platform: 'macos', arch: 'arm64', model: 'Mac16,2' }),
+    postJson: async () => ({
+      instance_id: 'tinst_sams_imac',
+      connection_id: 'conn_mac_local',
+      enrollment_token: 'tok_pair',
+      endpoint_url: 'https://localpty.inneranimalmedia.com',
+    }),
+    pairImpl: async (token) => {
+      pairedToken = token;
+      return { ok: true };
+    },
+  });
+  assert.equal(pairedToken, 'tok_pair');
+  assert.equal(result.paired, true);
+  assert.equal(result.auth_mode, 'connection_token');
+});
+
+test('normalizer matches the worker vocabulary', () => {
+  assert.equal(normalizeTerminalPlatform('darwin'), 'macos');
+  assert.equal(normalizeTerminalPlatform('win32'), 'windows');
+  assert.equal(normalizeTerminalArch('x64'), 'x86_64');
+  assert.equal(normalizeTerminalArch('aarch64'), 'arm64');
+});

package/test/whoami-resume.test.mjs

@@ -32,8 +32,23 @@ test('whoami validates persisted IAM browser identity while never returning acco
         cloudflare: { ok: true }, byok: { openai: { configured: true, masked: 'secret' } },
         terminal: {
           available: true,
-          instances: [{ id: 'inst_1', name: 'Mac', metadata_json: 'secret' }],
-          connections: [{ id: 'conn_1', instance_id: 'inst_1', name: 'Tunnel', is_active: true, endpoint_url: 'wss://secret' }],
+          instances: [{
+            id: 'inst_1',
+            name: 'Mac',
+            provider: 'local',
+            last_seen_at: 1789716970,
+            metadata_json: 'secret',
+          }],
+          connections: [{
+            id: 'conn_1',
+            instance_id: 'inst_1',
+            name: 'Tunnel',
+            is_active: true,
+            is_default: true,
+            transport_provider: 'cloudflare_tunnel',
+            endpoint_url: 'wss://localpty.example.test/terminal',
+            last_seen_at: 1789716970,
+          }],
         },
       };
     },
@@ -41,11 +56,17 @@ test('whoami validates persisted IAM browser identity while never returning acco
   assert.equal(status.authenticated, true);
   assert.equal(status.identity.account_id, 'acct_server');
   assert.equal(status.active_auth.source, 'agentsam_browser_oauth');
-  assert.equal(status.active_auth.kind, 'browser_oauth');
+  assert.equal(status.active_auth.kind, 'agentsam_browser_oauth');
   assert.equal(status.provider_credentials.find(row => row.provider === 'openai').configured, true);
+  assert.equal(status.provider_credentials.find(row => row.provider === 'openai').owner_account_id, 'acct_server');
+  assert.equal(status.provider_credentials.find(row => row.provider === 'openai').account_id, 'acct_server');
+  assert.equal(status.identity.email, 'dev@example.test');
   assert.equal(status.terminal.connections[0].id, 'conn_1');
+  assert.equal(status.terminal.connections[0].connection_id, 'conn_1');
+  assert.equal(status.terminal.connections[0].public_url, 'wss://localpty.example.test/terminal');
+  assert.match(status.terminal.connections[0].last_seen_at_iso || '', /^2026-/);
   const serialized = JSON.stringify(status);
-  assert.doesNotMatch(serialized, /browser_session_do_not_print|sk-never-print-this|masked|endpoint_url|metadata_json|wss:\/\/secret/);
+  assert.doesNotMatch(serialized, /browser_session_do_not_print|sk-never-print-this|masked|metadata_json/);
 });
 
 test('whoami sends the exact authority returned by the resolver to the default context loader', async t => {
@@ -86,7 +107,7 @@ test('whoami uses a valid browser session when a stale environment API key is in
     },
   });
   assert.equal(status.authenticated, true);
-  assert.equal(status.active_auth.kind, 'browser_oauth');
+  assert.equal(status.active_auth.kind, 'agentsam_browser_oauth');
   assert.equal(status.api_key.valid, false);
   assert.equal(status.api_key.error, 'invalid_api_key_prefix');
 });
@@ -115,7 +136,7 @@ test('whoami refreshes an expired browser session before validating IAM context'
   });
   assert.equal(refreshed, 1);
   assert.equal(status.authenticated, true);
-  assert.equal(status.active_auth.kind, 'browser_oauth');
+  assert.equal(status.active_auth.kind, 'agentsam_browser_oauth');
 });
 
 test('resume restores saved cwd and session through the canonical shell runtime', async t => {

package/packages/agentsam-brand/test/brand-scan.test.mjs

@@ -1,106 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import test from 'node:test';
-import { execFileSync } from 'node:child_process';
-import { brandScan, brandResolve } from '../src/index.js';
-import { repositorySnapshot } from '../../../src/capabilities/index.js';
-import { scanTrustBoundary } from '../../../src/security/trust-boundary.js';
-import { suggestNextActions, routeDeterministicIntent } from '../../../src/progression/index.js';
-
-function fixtureRepo() {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-brand-'));
-  execFileSync('git', ['init'], { cwd: root, stdio: 'ignore' });
-  execFileSync('git', ['config', 'user.email', 'test@example.com'], { cwd: root, stdio: 'ignore' });
-  execFileSync('git', ['config', 'user.name', 'Test'], { cwd: root, stdio: 'ignore' });
-  fs.writeFileSync(path.join(root, '.gitignore'), 'ignored/\nnode_modules/\n');
-  fs.mkdirSync(path.join(root, 'src/styles'), { recursive: true });
-  fs.mkdirSync(path.join(root, 'src/components'), { recursive: true });
-  fs.mkdirSync(path.join(root, 'ignored'), { recursive: true });
-  fs.writeFileSync(
-    path.join(root, 'src/styles/theme.css'),
-    `:root {\n  --color-slate-950: #0f172a;\n  --black: #111111;\n  color: #101010;\n  background: rgb(17, 17, 17);\n  font-family: "Inter", system-ui;\n  font-size: 16px;\n  border-radius: 8px;\n}\n`,
-  );
-  fs.writeFileSync(
-    path.join(root, 'src/components/Button.tsx'),
-    `export function Button() { return <button className="bg-neutral-950 text-white">Go</button>; }\n`,
-  );
-  fs.writeFileSync(
-    path.join(root, 'src/components/Header.tsx'),
-    `export function Header() { return <header style={{ background: '#0f172a' }}>Nav</header>; }\n`,
-  );
-  fs.writeFileSync(path.join(root, 'ignored/secret.css'), `:root { --should-not-see: #ff0000; }\n`);
-  execFileSync('git', ['add', '.'], { cwd: root, stdio: 'ignore' });
-  execFileSync('git', ['commit', '-m', 'init'], { cwd: root, stdio: 'ignore' });
-  return root;
-}
-
-test('brand.scan derives stable brand evidence from repository snapshot', async (t) => {
-  const root = fixtureRepo();
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-
-  const snapshot = await repositorySnapshot({ cwd: root, churnDays: 30 });
-  const one = await brandScan({ cwd: root, snapshot });
-  const two = await brandScan({ cwd: root, snapshot });
-
-  assert.equal(one.capability, 'brand.scan');
-  assert.equal(one.deterministic, true);
-  assert.equal(one.model_required, false);
-  assert.equal(one.repository.snapshot_id, snapshot.snapshot_id);
-  assert.equal(one.repository.snapshot_id, two.repository.snapshot_id);
-  assert.match(one.content_hash, /^sha256:[a-f0-9]{64}$/);
-  assert.equal(one.content_hash, two.content_hash);
-  assert.deepEqual(one.tokens.colors.map((c) => c.normalized_value), two.tokens.colors.map((c) => c.normalized_value));
-  assert.ok(one.tokens.colors.length >= 2);
-  assert.equal(one.sources.css >= 1, true);
-});
-
-test('brand scan and repository inspection share one file authority', async (t) => {
-  const root = fixtureRepo();
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-
-  const snapshot = await repositorySnapshot({ cwd: root, churnDays: 30 });
-  const boundary = await scanTrustBoundary(root);
-  const brand = await brandScan({ cwd: root, snapshot });
-
-  assert.equal(snapshot.tree.merkle_root, boundary.merkle_root);
-  assert.equal(snapshot.tree.metadata_root, boundary.metadata_root);
-  assert.equal(brand.repository.merkle_root, snapshot.tree.merkle_root);
-  assert.equal(brand.repository.path_count, snapshot.tree.paths.length);
-  assert.equal(snapshot.tree.paths.some((p) => p.startsWith('ignored/')), false);
-  assert.equal(
-    JSON.stringify(brand).includes('should-not-see') || JSON.stringify(brand).includes('#ff0000'),
-    false,
-  );
-});
-
-test('brand.resolve keeps observed/inferred/declared/resolved separated', async (t) => {
-  const root = fixtureRepo();
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const snapshot = await repositorySnapshot({ cwd: root, churnDays: 30 });
-  const scan = await brandScan({ cwd: root, snapshot });
-  const resolved = brandResolve(scan);
-  assert.equal(resolved.capability, 'brand.resolve');
-  assert.ok(Array.isArray(resolved.observed.colors));
-  assert.equal(typeof resolved.inferred.colors, 'object');
-  assert.deepEqual(resolved.declared, {});
-  assert.equal(typeof resolved.resolved.colors, 'object');
-});
-
-test('progression engine suggests brand next actions without a model', () => {
-  const { next_actions } = suggestNextActions({
-    capability: 'brand.scan',
-    result: { conflicts: [{ kind: 'near_duplicate_color' }], complete: true },
-  });
-  assert.ok(next_actions.some((a) => a.id === 'brand.inspect.conflicts'));
-  assert.ok(next_actions.some((a) => a.command?.includes('plan brand')));
-  assert.equal(next_actions.every((a) => a.requires_model === false), true);
-});
-
-test('deterministic intent router handles what next without a model', () => {
-  const hit = routeDeterministicIntent('what should I do next?');
-  assert.equal(hit.intent, 'next');
-  assert.equal(hit.use_progression, true);
-  assert.equal(routeDeterministicIntent('show brand').command, 'agentsam brand');
-});

package/packages/agentsam-nav/dist/Nav.d.ts

@@ -1,43 +0,0 @@
-import { type HTMLAttributes } from 'react';
-import { NavCollapsible, NavCollapsibleContent, NavCollapsibleTrigger } from './NavCollapsible.js';
-import { NavContent } from './NavContent.js';
-import { NavFooter } from './NavFooter.js';
-import { NavGroup, NavGroupLabel } from './NavGroup.js';
-import { NavHeader } from './NavHeader.js';
-import { NavMenu, NavMenuButton, NavMenuChevron, NavMenuItem, NavMenuSub, NavMenuSubButton } from './NavMenu.js';
-import { NavProvider } from './NavProvider.js';
-import { NavTrigger } from './NavTrigger.js';
-import { NavScope, NavSidenav, NavTopbar, NavTopbarLogo, NavTopbarSpacer, NavProjectContext, NavAccountSwitcher, NavFilesResources, NavPinnedSummary, NavConversationActions, NavShareButton, NavOverflowMenu, NavModeSwitcher } from './Surfaces.js';
-declare function NavRoot({ className, children, ...props }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
-export declare const Nav: typeof NavRoot & {
-    Scope: typeof NavScope;
-    Sidenav: typeof NavSidenav;
-    Topbar: typeof NavTopbar;
-    TopbarLogo: typeof NavTopbarLogo;
-    TopbarSpacer: typeof NavTopbarSpacer;
-    ProjectContext: typeof NavProjectContext;
-    AccountSwitcher: typeof NavAccountSwitcher;
-    FilesResources: typeof NavFilesResources;
-    PinnedSummary: typeof NavPinnedSummary;
-    ConversationActions: typeof NavConversationActions;
-    ShareButton: typeof NavShareButton;
-    OverflowMenu: typeof NavOverflowMenu;
-    ModeSwitcher: typeof NavModeSwitcher;
-    Provider: typeof NavProvider;
-    Header: typeof NavHeader;
-    Content: typeof NavContent;
-    Footer: typeof NavFooter;
-    Group: typeof NavGroup;
-    GroupLabel: typeof NavGroupLabel;
-    Menu: typeof NavMenu;
-    MenuItem: typeof NavMenuItem;
-    MenuButton: typeof NavMenuButton;
-    MenuSub: typeof NavMenuSub;
-    MenuSubButton: typeof NavMenuSubButton;
-    MenuChevron: typeof NavMenuChevron;
-    Collapsible: typeof NavCollapsible;
-    CollapsibleTrigger: typeof NavCollapsibleTrigger;
-    CollapsibleContent: typeof NavCollapsibleContent;
-    Trigger: typeof NavTrigger;
-};
-export {};

package/packages/agentsam-nav/dist/NavCollapsible.d.ts

@@ -1,10 +0,0 @@
-import { type ButtonHTMLAttributes, type HTMLAttributes, type ReactElement, type ReactNode } from 'react';
-export declare function NavCollapsible({ children, defaultOpen }: {
-    children: ReactNode;
-    defaultOpen?: boolean;
-}): import("react").JSX.Element;
-export declare function NavCollapsibleTrigger({ render, children, className, ...props }: ButtonHTMLAttributes<HTMLButtonElement> & {
-    render?: ReactElement;
-    children?: ReactNode;
-}): import("react").JSX.Element;
-export declare function NavCollapsibleContent({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;

package/packages/agentsam-nav/dist/NavContent.d.ts

@@ -1,2 +0,0 @@
-import type { HTMLAttributes } from 'react';
-export declare function NavContent({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;

package/packages/agentsam-nav/dist/NavFooter.d.ts

@@ -1,2 +0,0 @@
-import type { HTMLAttributes } from 'react';
-export declare function NavFooter({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;

package/packages/agentsam-nav/dist/NavGroup.d.ts

@@ -1,3 +0,0 @@
-import type { HTMLAttributes } from 'react';
-export declare function NavGroup({ className, ...props }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
-export declare function NavGroupLabel({ className, ...props }: HTMLAttributes<HTMLParagraphElement>): import("react").JSX.Element;

package/packages/agentsam-nav/dist/NavHeader.d.ts

@@ -1,2 +0,0 @@
-import type { HTMLAttributes } from 'react';
-export declare function NavHeader({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;

package/packages/agentsam-nav/dist/NavMenu.d.ts

@@ -1,22 +0,0 @@
-import type { ButtonHTMLAttributes, HTMLAttributes, ReactNode } from 'react';
-export declare function NavMenu({ className, ...props }: HTMLAttributes<HTMLUListElement>): import("react").JSX.Element;
-export declare function NavMenuItem({ className, ...props }: HTMLAttributes<HTMLLIElement>): import("react").JSX.Element;
-export type NavMenuButtonProps = ButtonHTMLAttributes<HTMLButtonElement> & {
-    icon?: unknown;
-    active?: boolean;
-    itemId?: string;
-    children: ReactNode;
-};
-export declare function NavMenuButton({ icon: Icon, active, itemId, className, children, ...props }: NavMenuButtonProps): import("react").JSX.Element;
-export declare function NavMenuSub({ className, ...props }: HTMLAttributes<HTMLUListElement>): import("react").JSX.Element;
-export type NavMenuSubButtonProps = {
-    href?: string;
-    active?: boolean;
-    className?: string;
-    children?: unknown;
-    onClick?: (event: React.MouseEvent<HTMLAnchorElement>) => void;
-};
-export declare function NavMenuSubButton({ active, className, children, ...props }: NavMenuSubButtonProps): import("react").JSX.Element;
-export declare function NavMenuChevron({ className }: {
-    className?: string;
-}): import("react").JSX.Element;

package/packages/agentsam-nav/dist/NavProvider.d.ts

@@ -1,35 +0,0 @@
-import { type PropsWithChildren } from 'react';
-import type { NavTheme, NavValue, NavTokens } from './contracts.js';
-export type NavContextValue = {
-    data: NavValue;
-    tokens: NavTokens;
-    theme: NavTheme;
-    accentColor: string;
-    menu: string | null;
-    setMenu: (menu: string | null) => void;
-    open: boolean;
-    isMobile: boolean;
-    isPeeking: boolean;
-    peekable: boolean;
-    resizable: boolean;
-    width: number;
-    mobileBreakpoint: number;
-    setOpen: (open: boolean) => void;
-    toggle: () => void;
-    close: () => void;
-    setPeeking: (peeking: boolean) => void;
-    setWidth: (width: number) => void;
-    scrollToItem: (itemId: string) => void;
-};
-export type NavProviderProps = PropsWithChildren<{
-    value?: NavValue;
-    tokens?: NavTokens;
-    theme?: NavTheme;
-    accentColor?: string;
-    defaultOpen?: boolean;
-    mobileBreakpoint?: number;
-    peekable?: boolean;
-    resizable?: boolean;
-}>;
-export declare function NavProvider({ children, value: data, tokens, theme, accentColor, defaultOpen, mobileBreakpoint, peekable, resizable, }: NavProviderProps): import("react").JSX.Element;
-export declare function useNav(): NavContextValue;

package/packages/agentsam-nav/dist/NavTrigger.d.ts

@@ -1,2 +0,0 @@
-import type { ButtonHTMLAttributes } from 'react';
-export declare function NavTrigger({ className, 'aria-label': ariaLabel, ...props }: ButtonHTMLAttributes<HTMLButtonElement>): import("react").JSX.Element;

package/packages/agentsam-nav/dist/Surfaces.d.ts

@@ -1,41 +0,0 @@
-import { type CSSProperties, type HTMLAttributes, type ReactNode } from 'react';
-import type { NavAccount, NavAction } from './contracts.js';
-export declare function useNavStyle(): CSSProperties;
-export declare function NavScope({ className, style, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
-/** The portal carries its own theme, so standalone surfaces never depend on body CSS. */
-export declare function NavOverflowMenu({ label, actions, children, id: suppliedId, align }: {
-    label?: string;
-    actions?: NavAction[];
-    children?: ReactNode;
-    id?: string;
-    align?: 'start' | 'center' | 'end';
-}): import("react").JSX.Element;
-export declare function NavTopbarLogo({ variant, onClick, toggle }: {
-    variant?: 'mark' | 'expanded';
-    onClick?: () => void;
-    toggle?: boolean;
-}): import("react").JSX.Element;
-export declare function NavProjectContext(): import("react").JSX.Element;
-export declare function NavTopbarSpacer(): import("react").JSX.Element;
-export declare function NavFilesResources(): import("react").JSX.Element;
-export declare function NavPinnedSummary(): import("react").JSX.Element | null;
-export declare function NavConversationActions(): import("react").JSX.Element;
-export declare function NavShareButton(): import("react").JSX.Element | null;
-export declare function NavAccountSwitcher({ accounts, activeAccountId, onAccountChange, expanded }: {
-    accounts?: NavAccount[];
-    activeAccountId?: string;
-    onAccountChange?: (id: string) => void;
-    expanded?: boolean;
-}): import("react").JSX.Element;
-export declare function NavModeSwitcher(): import("react").JSX.Element;
-export declare function NavTopbar({ children, rightSlot, modeSlot, contextSlot, startup, className, showNavigationTrigger, showAccount, }: {
-    children?: ReactNode;
-    rightSlot?: ReactNode;
-    modeSlot?: ReactNode;
-    contextSlot?: ReactNode;
-    startup?: boolean;
-    className?: string;
-    showNavigationTrigger?: boolean;
-    showAccount?: boolean;
-}): import("react").JSX.Element;
-export declare function NavSidenav(): import("react").JSX.Element;

package/packages/agentsam-nav/dist/browser.d.ts

@@ -1,11 +0,0 @@
-import type { NavProviderProps } from './NavProvider.js';
-export interface MountNavOptions extends Omit<NavProviderProps, 'children'> {
-    sidenav?: HTMLElement;
-    topbar?: HTMLElement;
-    startup?: boolean;
-}
-/** Plain HTML integration. Both portals are descendants of the same provider. */
-export declare function mountNav(options: MountNavOptions): {
-    update(next: Partial<MountNavOptions>): void;
-    unmount(): void;
-};