picocode-core 0.9.119

package/src/models.js

@@ -0,0 +1,14 @@
+export function findModel(models, name) {
+  return models.find((m) => m.name === name) || null
+}
+
+export function defaultModel(models) {
+  return models.find((m) => m.available !== false) || null
+}
+
+export function estimateCost(model, usage) {
+  if (!model?.price || !usage) return 0
+  const inCost = (usage.promptTokens || 0) * model.price.in
+  const outCost = (usage.completionTokens || 0) * model.price.out
+  return (inCost + outCost) / 1e6
+}

package/src/openai-auth.js

@@ -0,0 +1,204 @@
+import { createServer } from 'node:http'
+import { randomBytes, createHash } from 'node:crypto'
+import { execFile } from 'node:child_process'
+import { readFile, writeFile, chmod } from 'node:fs/promises'
+import { join } from 'node:path'
+import { picoHome, ensureDir } from './paths.js'
+
+const CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann'
+const AUTH_URL = 'https://auth.openai.com/oauth/authorize'
+const TOKEN_URL = 'https://auth.openai.com/oauth/token'
+const REDIRECT_PORT = 1455
+const REDIRECT_URI = `http://localhost:${REDIRECT_PORT}/auth/callback`
+const SCOPE = 'openid profile email offline_access'
+const REFRESH_SKEW_MS = 5 * 60 * 1000
+
+function authFile() {
+  return join(picoHome(), 'auth.json')
+}
+
+function openInBrowser(url) {
+  const [command, args] = process.platform === 'darwin'
+    ? ['open', [url]]
+    : process.platform === 'win32'
+      ? ['explorer.exe', [url]]
+      : ['xdg-open', [url]]
+  execFile(command, args, () => {})
+}
+
+function base64url(buffer) {
+  return buffer.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+}
+
+export function decodeJwtClaims(token) {
+  try {
+    const payload = token.split('.')[1]
+    return JSON.parse(Buffer.from(payload, 'base64url').toString('utf-8'))
+  } catch {
+    return {}
+  }
+}
+
+export function accountIdFromClaims(claims) {
+  return claims['https://api.openai.com/auth']?.chatgpt_account_id || claims.chatgpt_account_id || null
+}
+
+async function readAuth() {
+  try {
+    return JSON.parse(await readFile(authFile(), 'utf-8'))
+  } catch {
+    return {}
+  }
+}
+
+async function writeAuth(auth) {
+  ensureDir(picoHome())
+  await writeFile(authFile(), JSON.stringify(auth, null, 2) + '\n')
+  await chmod(authFile(), 0o600)
+}
+
+async function tokenRequest(params) {
+  const response = await fetch(TOKEN_URL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: new URLSearchParams(params).toString(),
+  })
+  if (!response.ok) {
+    throw new Error(`token request failed: ${response.status} ${await response.text()}`)
+  }
+  return response.json()
+}
+
+function storeTokens(auth, tokens) {
+  const claims = tokens.id_token ? decodeJwtClaims(tokens.id_token) : {}
+  auth.openai = {
+    access_token: tokens.access_token,
+    refresh_token: tokens.refresh_token || auth.openai?.refresh_token,
+    id_token: tokens.id_token || auth.openai?.id_token,
+    account_id: accountIdFromClaims(claims) || auth.openai?.account_id || null,
+    email: claims.email || auth.openai?.email || null,
+    expires_at: Date.now() + (tokens.expires_in || 3600) * 1000,
+  }
+  return auth
+}
+
+export async function connectOpenAI({ openBrowser = true, timeoutMs = 5 * 60 * 1000, onUrl = () => {} } = {}) {
+  const verifier = base64url(randomBytes(64))
+  const challenge = base64url(createHash('sha256').update(verifier).digest())
+  const state = base64url(randomBytes(24))
+
+  const url = `${AUTH_URL}?${new URLSearchParams({
+    response_type: 'code',
+    client_id: CLIENT_ID,
+    redirect_uri: REDIRECT_URI,
+    scope: SCOPE,
+    code_challenge: challenge,
+    code_challenge_method: 'S256',
+    state,
+    prompt: 'login',
+    id_token_add_organizations: 'true',
+    codex_cli_simplified_flow: 'true',
+    originator: 'codex_cli_rs',
+  }).toString()}`
+
+  const code = await new Promise((resolve, reject) => {
+    const server = createServer((req, res) => {
+      const requestUrl = new URL(req.url, `http://localhost:${REDIRECT_PORT}`)
+      if (requestUrl.pathname !== '/auth/callback') {
+        res.writeHead(404).end()
+        return
+      }
+      const gotState = requestUrl.searchParams.get('state')
+      const gotCode = requestUrl.searchParams.get('code')
+      const gotError = requestUrl.searchParams.get('error')
+      res.writeHead(200, { 'Content-Type': 'text/html' })
+      res.end(
+        gotCode && gotState === state
+          ? '<html><body style="font-family: sans-serif; padding: 2rem">signed in - you can return to pico</body></html>'
+          : '<html><body style="font-family: sans-serif; padding: 2rem">sign-in failed - return to pico and try again</body></html>',
+      )
+      cleanup()
+      if (gotError) reject(new Error(`authorization failed: ${gotError}`))
+      else if (!gotCode || gotState !== state) reject(new Error('authorization failed: missing code or state mismatch'))
+      else resolve(gotCode)
+    })
+
+    const timer = setTimeout(() => {
+      cleanup()
+      reject(new Error('sign-in timed out'))
+    }, timeoutMs)
+
+    function cleanup() {
+      clearTimeout(timer)
+      server.close()
+    }
+
+    server.on('error', (err) => {
+      cleanup()
+      reject(err.code === 'EADDRINUSE' ? new Error(`port ${REDIRECT_PORT} is in use (is another sign-in or codex running?)`) : err)
+    })
+    server.listen(REDIRECT_PORT, '127.0.0.1', () => {
+      onUrl(url)
+      if (openBrowser) openInBrowser(url)
+    })
+  })
+
+  const tokens = await tokenRequest({
+    grant_type: 'authorization_code',
+    code,
+    redirect_uri: REDIRECT_URI,
+    client_id: CLIENT_ID,
+    code_verifier: verifier,
+  })
+
+  const auth = storeTokens(await readAuth(), tokens)
+  await writeAuth(auth)
+  return { email: auth.openai.email, accountId: auth.openai.account_id }
+}
+
+export async function openaiCredentials() {
+  const auth = await readAuth()
+  const stored = auth.openai
+  if (!stored?.access_token) return null
+
+  if (Date.now() > (stored.expires_at || 0) - REFRESH_SKEW_MS) {
+    if (!stored.refresh_token) return null
+    const tokens = await tokenRequest({
+      grant_type: 'refresh_token',
+      refresh_token: stored.refresh_token,
+      client_id: CLIENT_ID,
+      scope: 'openid profile email',
+    })
+    const refreshed = storeTokens(auth, tokens)
+    await writeAuth(refreshed)
+    return credentialsFrom(refreshed.openai)
+  }
+  return credentialsFrom(stored)
+}
+
+function credentialsFrom(stored) {
+  return {
+    apiKey: stored.access_token,
+    headers: stored.account_id ? { 'chatgpt-account-id': stored.account_id } : {},
+    email: stored.email,
+  }
+}
+
+export async function openaiConnected() {
+  const auth = await readAuth()
+  return !!(auth.openai?.access_token && auth.openai?.refresh_token)
+}
+
+export async function openaiStatus() {
+  const auth = await readAuth()
+  return {
+    connected: !!(auth.openai?.access_token && auth.openai?.refresh_token),
+    email: auth.openai?.email || null,
+  }
+}
+
+export async function disconnectOpenAI() {
+  const auth = await readAuth()
+  delete auth.openai
+  await writeAuth(auth)
+}

package/src/paths.js

@@ -0,0 +1,67 @@
+import { existsSync, mkdirSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+
+export function picoHome() {
+  return process.env.PICO_HOME || join(homedir(), '.pico')
+}
+
+export function projectKey(root) {
+  return resolve(root).replace(/[/\\:]/g, '-')
+}
+
+export function findProjectRoot(cwd) {
+  let dir = resolve(cwd)
+  const home = homedir()
+  while (true) {
+    if (existsSync(join(dir, '.git'))) return dir
+    const parent = dirname(dir)
+    if (parent === dir || dir === home) return resolve(cwd)
+    dir = parent
+  }
+}
+
+export function projectDir(root) {
+  return join(picoHome(), 'projects', projectKey(root))
+}
+
+export function sessionsDir(root) {
+  return join(projectDir(root), 'sessions')
+}
+
+export function sessionScratchDir(root, sessionId) {
+  return join(projectDir(root), 'scratchpads', sessionId)
+}
+
+export function agentScratchDir(root, sessionId, agentId) {
+  return join(sessionScratchDir(root, sessionId), `agent-${agentId}`)
+}
+
+export function projectHistoryFile(root) {
+  return join(projectDir(root), 'history.jsonl')
+}
+
+export function projectMcpFile(root) {
+  return join(projectDir(root), 'mcp.json')
+}
+
+export function globalMcpFile() {
+  return join(picoHome(), 'mcp.json')
+}
+
+export function globalSkillsDir() {
+  return join(picoHome(), 'skills')
+}
+
+export function projectSkillsDir(root) {
+  return join(root, '.pico', 'skills')
+}
+
+export function globalAgentsFile() {
+  return join(picoHome(), 'AGENTS.md')
+}
+
+export function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true })
+  return dir
+}

package/src/reversible-edit.js

@@ -0,0 +1,79 @@
+import { createHash } from 'node:crypto'
+
+export const REVERSIBLE_EDIT_VERSION = 2
+
+export function contentHash(text) {
+  return createHash('sha256').update(text, 'utf-8').digest('hex')
+}
+
+function state(exists, text) {
+  return { exists, hash: exists ? contentHash(text) : null }
+}
+
+export function makeReversibleEdit(path, before, after, splices, { beforeExists = true, afterExists = true } = {}) {
+  return {
+    version: REVERSIBLE_EDIT_VERSION,
+    path,
+    before: state(beforeExists, before),
+    after: state(afterExists, after),
+    splices,
+  }
+}
+
+export function makeWriteEdit(path, before, after, beforeExists) {
+  let start = 0
+  const shared = Math.min(before.length, after.length)
+  while (start < shared && before.charCodeAt(start) === after.charCodeAt(start)) start++
+
+  let beforeEnd = before.length
+  let afterEnd = after.length
+  while (beforeEnd > start && afterEnd > start && before.charCodeAt(beforeEnd - 1) === after.charCodeAt(afterEnd - 1)) {
+    beforeEnd--
+    afterEnd--
+  }
+
+  return makeReversibleEdit(path, before, after, [{
+    start,
+    oldText: before.slice(start, beforeEnd),
+    newText: after.slice(start, afterEnd),
+  }], { beforeExists })
+}
+
+export function reversibleEditVersion(revert) {
+  if (revert?.version === REVERSIBLE_EDIT_VERSION && Array.isArray(revert.splices)) return 2
+  if (typeof revert?.before === 'string' && typeof revert?.after === 'string') return 1
+  return null
+}
+
+function validatedSplices(revert) {
+  let end = 0
+  return revert.splices.map((splice) => {
+    if (!Number.isSafeInteger(splice?.start) || splice.start < end || typeof splice.oldText !== 'string' || typeof splice.newText !== 'string') {
+      throw new Error('invalid reversible edit splices')
+    }
+    end = splice.start + splice.oldText.length
+    return splice
+  })
+}
+
+export function applySplices(source, revert, direction) {
+  const splices = validatedSplices(revert)
+  const parts = []
+  let sourceAt = 0
+  let delta = 0
+
+  for (const splice of splices) {
+    const start = direction === 'forward' ? splice.start : splice.start + delta
+    const oldText = direction === 'forward' ? splice.oldText : splice.newText
+    const newText = direction === 'forward' ? splice.newText : splice.oldText
+    if (start < sourceAt || start + oldText.length > source.length || source.slice(start, start + oldText.length) !== oldText) {
+      throw new Error('reversible edit does not match file content')
+    }
+    parts.push(source.slice(sourceAt, start), newText)
+    sourceAt = start + oldText.length
+    delta += splice.newText.length - splice.oldText.length
+  }
+
+  parts.push(source.slice(sourceAt))
+  return parts.join('')
+}

package/src/rewind.js

@@ -0,0 +1,84 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { dirname } from 'node:path'
+import { applySplices, contentHash, reversibleEditVersion } from './reversible-edit.js'
+
+export function implicitRewindTarget(state, input) {
+  if (input !== '') return null
+  const last = state.transcript.at(-1)
+  if (last?.kind !== 'user') return null
+  return { text: last.text, content: last.content, index: state.transcript.length - 1, eventId: last.eventId }
+}
+
+async function readCurrent(path) {
+  try {
+    return { exists: true, text: await readFile(path, 'utf-8') }
+  } catch (err) {
+    if (err.code === 'ENOENT') return { exists: false, text: '' }
+    throw err
+  }
+}
+
+function matches(current, expected) {
+  return current.exists === expected.exists && (!current.exists || contentHash(current.text) === expected.hash)
+}
+
+async function writeState(path, state) {
+  if (!state.exists) {
+    await rm(path, { force: true })
+    return
+  }
+  await mkdir(dirname(path), { recursive: true })
+  await writeFile(path, state.text, 'utf-8')
+}
+
+async function transform(edit, direction) {
+  const revert = edit.revert
+  const version = reversibleEditVersion(revert)
+  if (!version) return { reason: 'invalid reversible edit data' }
+  const current = await readCurrent(revert.path)
+
+  if (version === 1) {
+    const expected = direction === 'undo' ? revert.after : revert.before
+    if (!current.exists || current.text !== expected) return { reason: direction === 'undo' ? 'file changed since edit' : 'file changed since revert' }
+    await writeState(revert.path, { exists: true, text: direction === 'undo' ? revert.before : revert.after })
+    return { ok: true }
+  }
+
+  const expected = direction === 'undo' ? revert.after : revert.before
+  const target = direction === 'undo' ? revert.before : revert.after
+  if (!matches(current, expected)) return { reason: direction === 'undo' ? 'file changed since edit' : 'file changed since revert' }
+
+  try {
+    const text = applySplices(current.text, revert, direction === 'undo' ? 'reverse' : 'forward')
+    if (target.exists && contentHash(text) !== target.hash) return { reason: 'reversible edit data is corrupt' }
+    await writeState(revert.path, { exists: target.exists, text })
+    return { ok: true }
+  } catch {
+    return { reason: 'reversible edit data is corrupt' }
+  }
+}
+
+async function applyEdits(edits, direction) {
+  const applied = []
+  const skipped = []
+  for (const edit of direction === 'undo' ? [...edits].reverse() : edits) {
+    try {
+      const result = await transform(edit, direction)
+      if (result.ok) applied.push(edit.callId)
+      else skipped.push({ path: edit.revert?.path, callId: edit.callId, reason: result.reason })
+    } catch (err) {
+      skipped.push({ path: edit.revert?.path, callId: edit.callId, reason: err.message || String(err) })
+    }
+  }
+  return { applied, skipped }
+}
+
+export async function revertEdits(edits) {
+  const { applied, skipped } = await applyEdits(edits, 'undo')
+  return { reverted: applied, skipped }
+}
+
+export async function reapplyEdits(edits) {
+  const { applied, skipped } = await applyEdits(edits, 'redo')
+  return { reapplied: applied, skipped }
+}