@foundation0/api 1.1.2 → 1.1.4

package/agents.ts

@@ -39,7 +39,7 @@ interface ActiveConfigInput {
   required: boolean
 }
 
-const CLI_NAME = 'example'
+const CLI_NAME = 'f0'
 const AGENT_INITIAL_VERSION = 'v0.0.1'
 const DEFAULT_SKILL_NAME = 'coding-standards'
 const VERSION_RE = 'v?\\d+(?:\\.\\d+){2,}'
@@ -58,7 +58,7 @@ export function usage(): string {
     `Use --latest to resolve /file-name to the latest version.\n` +
     `The active file created is [file].active.<ext>.\n` +
     `Use "run" to start codex with developer_instructions from system/prompt.ts.\n` +
-    `Set EXAMPLE_CODEX_BIN to pin a specific codex binary.\n`
+    `Set F0_CODEX_BIN (or EXAMPLE_CODEX_BIN) to pin a specific codex binary.\n`
 }
 
 export function resolveAgentsRoot(processRoot: string = process.cwd()): string {
@@ -460,9 +460,9 @@ export function setActiveLink(sourceFile: string, activeFile: string): 'symlink'
 
   fs.mkdirSync(path.dirname(activeFile), { recursive: true })
 
-  if (fs.existsSync(activeFile)) {
-    fs.rmSync(activeFile, { force: true })
-  }
+  // Remove the active pointer first. Using rmSync directly (instead of existsSync)
+  // ensures we also clear broken symlinks (existsSync returns false for them).
+  fs.rmSync(activeFile, { force: true })
 
   const linkTarget = path.relative(path.dirname(activeFile), sourceFile)
 
@@ -643,7 +643,7 @@ type SpawnCodexResult = {
 type SpawnCodexFn = (args: string[]) => SpawnCodexResult
 
 function getCodexCommand(): string {
-  const override = process.env.EXAMPLE_CODEX_BIN?.trim()
+  const override = process.env.F0_CODEX_BIN?.trim() ?? process.env.EXAMPLE_CODEX_BIN?.trim()
   if (override) {
     return override
   }
@@ -666,6 +666,7 @@ const defaultSpawnCodex: SpawnCodexFn = (args) => {
     const err = primary.error as NodeJS.ErrnoException
     if (
       process.platform === 'win32'
+      && !process.env.F0_CODEX_BIN
       && !process.env.EXAMPLE_CODEX_BIN
       && primaryCommand === 'codex.cmd'
       && err.code === 'ENOENT'

package/git.ts

@@ -5,7 +5,7 @@ export type {
   GitServiceApi,
   GitServiceApiExecutionResult,
   GitServiceApiMethod,
-} from '../git/packages/git/src/index.ts'
+} from '@foundation0/git'
 
 export {
   attachGitLabelManagementApi,
@@ -17,4 +17,4 @@ export {
   extractDependencyIssueNumbers,
   resolveProjectRepoIdentity,
   syncIssueDependencies,
-} from '../git/packages/git/src/index.ts'
+} from '@foundation0/git'

package/libs/curl.test.ts

@@ -0,0 +1,130 @@
+import { describe, expect, it } from 'bun:test'
+import { curl } from './curl'
+
+describe('api/libs/curl', () => {
+  const withServer = async <T>(fn: (baseUrl: string) => Promise<T>): Promise<T> => {
+    const server = Bun.serve({
+      port: 0,
+      fetch: async (req) => {
+        const url = new URL(req.url)
+
+        if (url.pathname === '/hello') {
+          return new Response('hello', { headers: { 'x-test': '1' } })
+        }
+
+        if (url.pathname === '/echo') {
+          const body = await req.text()
+          return Response.json({
+            method: req.method,
+            body,
+            contentType: req.headers.get('content-type'),
+            ua: req.headers.get('user-agent'),
+          })
+        }
+
+        if (url.pathname === '/redirect') {
+          return new Response('nope', { status: 302, headers: { location: '/hello' } })
+        }
+
+        return new Response('not found', { status: 404 })
+      },
+    })
+
+    try {
+      return await fn(`http://127.0.0.1:${server.port}`)
+    } finally {
+      server.stop(true)
+    }
+  }
+
+  it('fetches a URL and returns body on stdout', async () => {
+    await withServer(async (baseUrl) => {
+      const result = await curl(`${baseUrl}/hello`)
+      expect(result.exitCode).toBe(0)
+      expect(result.timedOut).toBe(false)
+      expect(result.stdout).toBe('hello')
+      expect(result.results?.[0]?.httpCode).toBe(200)
+    })
+  })
+
+  it('defaults scheme-less host URLs to http://', async () => {
+    await withServer(async (baseUrl) => {
+      const url = baseUrl.replace('http://', '')
+      const result = await curl(`${url}/hello`)
+      expect(result.exitCode).toBe(0)
+      expect(result.stdout).toBe('hello')
+    })
+  })
+
+  it('supports -i to include response headers', async () => {
+    await withServer(async (baseUrl) => {
+      const result = await curl('-i', `${baseUrl}/hello`)
+      expect(result.exitCode).toBe(0)
+      expect(result.stdout).toContain('HTTP/1.1 200')
+      expect(result.stdout.toLowerCase()).toContain('x-test: 1')
+      expect(result.stdout).toContain('hello')
+    })
+  })
+
+  it('supports -d for POST body and defaults method to POST', async () => {
+    await withServer(async (baseUrl) => {
+      const result = await curl('-d', 'a=1', `${baseUrl}/echo`)
+      expect(result.exitCode).toBe(0)
+      const payload = JSON.parse(result.stdout)
+      expect(payload.method).toBe('POST')
+      expect(payload.body).toBe('a=1')
+      expect(payload.contentType).toContain('application/x-www-form-urlencoded')
+    })
+  })
+
+  it('supports -G with -d to apply data as query params', async () => {
+    await withServer(async (baseUrl) => {
+      const result = await curl('-G', '-d', 'a=1', `${baseUrl}/hello`)
+      expect(result.exitCode).toBe(0)
+      expect(result.stdout).toBe('hello')
+    })
+  })
+
+  it('supports -L to follow redirects', async () => {
+    await withServer(async (baseUrl) => {
+      const result = await curl('-L', `${baseUrl}/redirect`)
+      expect(result.exitCode).toBe(0)
+      expect(result.results?.[0]?.redirectCount).toBe(1)
+      expect(result.results?.[0]?.urlEffective).toContain('/hello')
+      expect(result.stdout).toBe('hello')
+    })
+  })
+
+  it('supports -f to fail on HTTP >= 400 and suppress body', async () => {
+    await withServer(async (baseUrl) => {
+      const result = await curl('-f', `${baseUrl}/missing`)
+      expect(result.exitCode).toBe(22)
+      expect(result.stdout).toBe('')
+      expect(result.stderr).toContain('returned error')
+    })
+  })
+
+  it('supports -w to write out %{http_code}', async () => {
+    await withServer(async (baseUrl) => {
+      const result = await curl('-w', '%{http_code}', `${baseUrl}/hello`)
+      expect(result.exitCode).toBe(0)
+      expect(result.stdout).toBe('hello200')
+    })
+  })
+
+  it('accepts trailing tool options object without turning it into a curl arg', async () => {
+    await withServer(async (baseUrl) => {
+      const result = await curl(`${baseUrl}/hello`, { timeoutMs: 10_000 })
+      expect(result.exitCode).toBe(0)
+      expect(result.args).toEqual([`${baseUrl}/hello`])
+    })
+  })
+
+  it('returns usage exit code for unsupported flags', async () => {
+    await withServer(async (baseUrl) => {
+      const result = await curl('--version', `${baseUrl}/hello`)
+      expect(result.exitCode).toBe(2)
+      expect(result.stderr).toContain('Unsupported curl option')
+    })
+  })
+})