@alumbwe/anvil 1.0.0

package/src/data/slash-commands.ts

@@ -0,0 +1,249 @@
+import { AGENT_MODES, IS_FREEBUFF } from '../utils/constants'
+
+import type { SkillsMap } from '@anvil/common/types/skill'
+
+
+export interface SlashCommand {
+  id: string
+  label: string
+  description: string
+  aliases?: string[]
+  /**
+   * If true, this command can be invoked without a leading slash when the
+   * input matches the command id exactly (no arguments).
+   */
+  implicitCommand?: boolean
+  /**
+   * If set, selecting this command inserts this text into the input field
+   * instead of executing a command. Useful for agent shortcuts.
+   */
+  insertText?: string
+}
+
+// Generate mode commands from the AGENT_MODES constant (excluded in Freebuff)
+const MODE_COMMANDS: SlashCommand[] = IS_FREEBUFF
+  ? []
+  : AGENT_MODES.map((mode) => ({
+      id: `mode:${mode.toLowerCase()}`,
+      label: `mode:${mode.toLowerCase()}`,
+      description: `Switch to ${mode} mode`,
+      aliases: [`model:${mode.toLowerCase()}`],
+    }))
+
+const FREEBUFF_REMOVED_COMMAND_IDS = new Set([
+  'ads:enable',
+  'ads:disable',
+  'usage',
+  'subscribe',
+  'agent:gpt-5',
+  'image',
+  'publish',
+  'init',
+])
+
+const FREEBUFF_ONLY_COMMAND_IDS = new Set([
+  'plan',
+  'end-session',
+  'dashboard',
+])
+
+const ALL_SLASH_COMMANDS: SlashCommand[] = [
+  {
+    id: 'help',
+    label: 'help',
+    description: 'Display keyboard shortcuts and tips',
+    aliases: ['h', '?'],
+    implicitCommand: true,
+  },
+  {
+    id: 'diagnostics',
+    label: 'diagnostics',
+    description: 'Show local CLI resource usage and terminal tool process IDs',
+    aliases: ['diag', 'processes'],
+  },
+  {
+    id: 'ads:enable',
+    label: 'ads:enable',
+    description: 'Enable contextual ads',
+  },
+  {
+    id: 'ads:disable',
+    label: 'ads:disable',
+    description: 'Disable contextual ads',
+  },
+  {
+    id: 'init',
+    label: 'init',
+    description: 'Create a starter knowledge.md file',
+    implicitCommand: true,
+  },
+  // {
+  //   id: 'undo',
+  //   label: 'undo',
+  //   description: 'Undo the last change made by the assistant',
+  // },
+  // {
+  //   id: 'redo',
+  //   label: 'redo',
+  //   description: 'Redo the most recent undone change',
+  // },
+  {
+    id: 'usage',
+    label: 'usage',
+    description: 'View credits and subscription quota',
+    aliases: ['credits'],
+  },
+  {
+    id: 'subscribe',
+    label: 'subscribe',
+    description: 'Subscribe to get more usage',
+    aliases: ['strong', 'sub', 'buy-credits'],
+  },
+  {
+    id: 'interview',
+    label: 'interview',
+    description: 'AI asks a series of questions to flesh out request into a spec',
+  },
+  {
+    id: 'plan',
+    label: 'plan',
+    description: 'Create a plan for how to implement a request',
+  },
+  {
+    id: 'review',
+    label: 'review',
+    description: 'Review code changes',
+  },
+  {
+    id: 'queue',
+    label: 'queue',
+    description: 'Edit, reorder, or delete the messages waiting to be sent',
+    aliases: ['queued'],
+  },
+  {
+    id: 'new',
+    label: 'new',
+    description: 'Clear the conversation history and start a new chat',
+    aliases: ['n', 'clear', 'c', 'reset'],
+    implicitCommand: true,
+  },
+  {
+    id: 'history',
+    label: 'history',
+    description: 'Browse and resume past conversations',
+    aliases: ['chats'],
+  },
+  {
+    id: 'copy',
+    label: 'copy',
+    description: 'Copy the full conversation (messages + tool results) to the clipboard',
+    aliases: ['copy-chat', 'export'],
+  },
+  {
+    id: 'agent:gpt-5',
+    label: 'agent:gpt-5',
+    description: 'Spawn the GPT-5 agent to help solve complex problems',
+    insertText: '@GPT-5 Agent ',
+  },
+  // {
+  //   id: 'agent:opus',
+  //   label: 'agent:opus',
+  //   description: 'Spawn the Opus agent to help solve any problem',
+  //   insertText: '@Opus Agent ',
+  // },
+  {
+    id: 'feedback',
+    label: 'feedback',
+    description: IS_FREEBUFF ? 'Share general feedback about Freebuff' : 'Share general feedback about Anvil',
+  },
+  {
+    id: 'bash',
+    label: 'bash',
+    description: 'Enter bash mode ("!" at beginning enters bash mode)',
+    aliases: ['!'],
+  },
+  {
+    id: 'image',
+    label: 'image',
+    description: 'Attach an image file (or Ctrl+V to paste from clipboard)',
+    aliases: ['img', 'attach'],
+  },
+  ...MODE_COMMANDS,
+  // {
+  //   id: 'publish',
+  //   label: 'publish',
+  //   description: 'Publish agents to the agent store',
+  // },
+  {
+    id: 'theme:toggle',
+    label: 'theme:toggle',
+    description: 'Toggle between light and dark mode',
+  },
+  {
+    id: 'end-session',
+    label: 'end-session',
+    description: 'End your free session (lets you switch model)',
+    aliases: ['model'],
+  },
+  {
+    id: 'dashboard',
+    label: 'dashboard',
+    description: 'Open your usage, streak and account dashboard in the browser',
+    aliases: ['usage', 'stats', 'streak'],
+  },
+  {
+    id: 'logout',
+    label: 'logout',
+    description: 'Sign out of your session',
+    aliases: ['signout'],
+    implicitCommand: true,
+  },
+  {
+    id: 'exit',
+    label: 'exit',
+    description: 'Quit the CLI',
+    aliases: ['quit', 'q'],
+    implicitCommand: true,
+  },
+]
+
+export const SLASH_COMMANDS = IS_FREEBUFF
+  ? ALL_SLASH_COMMANDS.filter(
+      (cmd) => !FREEBUFF_REMOVED_COMMAND_IDS.has(cmd.id),
+    )
+  : ALL_SLASH_COMMANDS.filter(
+      (cmd) => !FREEBUFF_ONLY_COMMAND_IDS.has(cmd.id),
+    )
+
+export const SLASHLESS_COMMAND_IDS = new Set(
+  SLASH_COMMANDS.filter((cmd) => cmd.implicitCommand).map((cmd) =>
+    cmd.id.toLowerCase(),
+  ),
+)
+
+/** Maximum description length for skill commands in the slash menu */
+const SKILL_MENU_DESCRIPTION_MAX_LENGTH = 50
+
+function truncateDescription(description: string): string {
+  if (description.length <= SKILL_MENU_DESCRIPTION_MAX_LENGTH) {
+    return description
+  }
+  return description.slice(0, SKILL_MENU_DESCRIPTION_MAX_LENGTH - 1) + '…'
+}
+
+/**
+ * Returns SLASH_COMMANDS merged with skill commands.
+ * Skills become slash commands that users can invoke directly.
+ */
+export function getSlashCommandsWithSkills(skills: SkillsMap): SlashCommand[] {
+  const skillCommands: SlashCommand[] = Object.values(skills).map((skill) => ({
+    id: `skill:${skill.name}`,
+    label: `skill:${skill.name}`,
+    description: truncateDescription(skill.description),
+    insertText: `/skill:${skill.name} `,
+  }))
+
+  const commands = [...SLASH_COMMANDS, ...skillCommands]
+
+  return commands
+}

package/src/entry.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env bun
+
+import {
+  isTerminalCommandBrokerInvocation,
+  serveTerminalCommandBroker,
+} from './utils/terminal-command-broker'
+
+if (isTerminalCommandBrokerInvocation(process.argv)) {
+  await serveTerminalCommandBroker()
+} else {
+  await import('./index')
+}

package/src/hooks/__tests__/holds-live-freebuff-slot.test.ts

@@ -0,0 +1,49 @@
+import { describe, test, expect } from 'bun:test'
+
+import { holdsLiveFreebuffSlot } from '../../utils/freebuff-session-api'
+
+import type { FreebuffSessionResponse } from '../../types/freebuff-session'
+
+// Gate predicate for both the message queue (may queued work still be sent?)
+// and slot release (is there a server row to DELETE?). The load-bearing cases
+// are the two 'ended' variants: WITH an instance id we're inside the server's
+// grace window and requests are still admissible; WITHOUT one the session is
+// fully over and any request would be rejected by the chat-completions gate.
+
+const activeSession: FreebuffSessionResponse = {
+  status: 'active',
+  accessTier: 'full',
+  instanceId: 'inst-1',
+  model: 'deepseek/deepseek-v4',
+  admittedAt: new Date().toISOString(),
+  expiresAt: new Date(Date.now() + 60_000).toISOString(),
+  remainingMs: 60_000,
+}
+
+describe('holdsLiveFreebuffSlot', () => {
+  test('active session holds a slot', () => {
+    expect(holdsLiveFreebuffSlot(activeSession)).toBe(true)
+  })
+
+  test('ended WITH instance id (grace window) still holds a slot', () => {
+    expect(
+      holdsLiveFreebuffSlot({ status: 'ended', instanceId: 'inst-1' }),
+    ).toBe(true)
+  })
+
+  test('ended WITHOUT instance id (post-grace) does not hold a slot', () => {
+    expect(holdsLiveFreebuffSlot({ status: 'ended' })).toBe(false)
+  })
+
+  test('null session does not hold a slot', () => {
+    expect(holdsLiveFreebuffSlot(null)).toBe(false)
+  })
+
+  test('pre-join and terminal states do not hold a slot', () => {
+    expect(holdsLiveFreebuffSlot({ status: 'none' })).toBe(false)
+    expect(holdsLiveFreebuffSlot({ status: 'superseded' })).toBe(false)
+    expect(
+      holdsLiveFreebuffSlot({ status: 'takeover_prompt', model: 'm' }),
+    ).toBe(false)
+  })
+})

package/src/hooks/__tests__/session-fetch-signal.test.ts

@@ -0,0 +1,63 @@
+import { describe, test, expect } from 'bun:test'
+
+import {
+  parseRetryAfterMs,
+  sessionFetchSignal,
+} from '../../utils/freebuff-session-api'
+
+// Every session API call gets this combined signal. The load-bearing cases:
+// the timeout must fire even when no caller signal is passed (DELETE paths),
+// and a poll-loop restart abort must win over the timeout so restarts stay
+// instant.
+
+const nextTick = () => new Promise<void>((resolve) => setTimeout(resolve, 0))
+
+describe('sessionFetchSignal', () => {
+  test('aborts after the timeout when no caller signal is given', async () => {
+    const signal = sessionFetchSignal(undefined, 5)
+    expect(signal.aborted).toBe(false)
+    await new Promise((resolve) => setTimeout(resolve, 20))
+    expect(signal.aborted).toBe(true)
+    expect((signal.reason as DOMException).name).toBe('TimeoutError')
+  })
+
+  test('propagates the caller abort before the timeout fires', async () => {
+    const caller = new AbortController()
+    const signal = sessionFetchSignal(caller.signal, 60_000)
+    expect(signal.aborted).toBe(false)
+    caller.abort()
+    await nextTick()
+    expect(signal.aborted).toBe(true)
+    expect((signal.reason as DOMException).name).toBe('AbortError')
+  })
+
+  test('times out even with a never-aborted caller signal', async () => {
+    const caller = new AbortController()
+    const signal = sessionFetchSignal(caller.signal, 5)
+    await new Promise((resolve) => setTimeout(resolve, 20))
+    expect(signal.aborted).toBe(true)
+    expect((signal.reason as DOMException).name).toBe('TimeoutError')
+  })
+
+  test('reflects an already-aborted caller signal immediately', () => {
+    const caller = new AbortController()
+    caller.abort()
+    const signal = sessionFetchSignal(caller.signal, 60_000)
+    expect(signal.aborted).toBe(true)
+  })
+})
+
+describe('parseRetryAfterMs', () => {
+  test('parses delta seconds and HTTP dates', () => {
+    expect(parseRetryAfterMs('10', 0)).toBe(10_000)
+    expect(parseRetryAfterMs('Thu, 01 Jan 1970 00:00:10 GMT', 2_000)).toBe(
+      8_000,
+    )
+  })
+
+  test('rejects invalid values and clamps past dates', () => {
+    expect(parseRetryAfterMs('invalid', 0)).toBeUndefined()
+    expect(parseRetryAfterMs('1e308', 0)).toBeUndefined()
+    expect(parseRetryAfterMs('Thu, 01 Jan 1970 00:00:01 GMT', 2_000)).toBe(0)
+  })
+})