pi-code 1.0.60 → 1.0.62

package/extensions/mcp/oauth-flow.ts

@@ -64,7 +64,7 @@ export async function runInteractiveOAuth(name: string, config: { url: string; o
     config.oauth,
     config.url,
   )
-  const { server, port } = await startCallbackServer(provider.savedRedirectPort())
+  const { server, port } = await startCallbackServer(provider.savedRedirectPort(), provider.configuredRedirectPort() !== undefined)
   provider.bindRedirectPort(port)
   try {
     const transport = makeTransport(provider)

package/extensions/mcp/transport.ts

@@ -5,6 +5,7 @@
  */
 
 import { execFile } from 'node:child_process'
+import * as fs from 'node:fs'
 import { pathToFileURL } from 'node:url'
 // SSE is deprecated in favour of Streamable HTTP, but the SDK notes servers still on
 // the old spec exist, so this stays as a fallback for the migration period.
@@ -182,8 +183,8 @@ function helperEnv(name: string, config: HttpServerConfig): NodeJS.ProcessEnv {
 }
 
 /** The env a stdio server process starts with: the SDK allowlist, the config's own
- * env block, and Claude's path variables (CLAUDE_PROJECT_DIR, and CLAUDE_PLUGIN_ROOT
- * for a plugin's server). */
+ * env block, and Claude's three path variables. Claude: "All three are exported as
+ * environment variables to hook processes and to MCP and LSP server subprocesses." */
 function stdioEnv(config: StdioServerConfig, fill: (value: string) => string, session?: SessionDirs): Record<string, string> {
   // CLAUDECODE marks every subprocess; the long-lived server deliberately gets no
   // CLAUDE_CODE_CHILD_SESSION, which Claude reserves for per-call children.
@@ -191,6 +192,16 @@ function stdioEnv(config: StdioServerConfig, fill: (value: string) => string, se
   for (const [key, value] of Object.entries(config.env ?? {})) env[key] = fill(value)
   if (session) env.CLAUDE_PROJECT_DIR = session.projectDir
   if (config.pluginRoot !== undefined) env.CLAUDE_PLUGIN_ROOT = config.pluginRoot
+  // The data dir is "created on first reference"; handing the path to a server is that
+  // reference, so the server does not have to mkdir it before using it.
+  if (config.pluginDataDir !== undefined) {
+    env.CLAUDE_PLUGIN_DATA = config.pluginDataDir
+    try {
+      fs.mkdirSync(config.pluginDataDir, { recursive: true })
+    } catch {
+      // The server still starts; one that needs the directory reports its own failure.
+    }
+  }
   return env
 }
 
@@ -234,7 +245,12 @@ export async function connect(name: string, config: ServerConfig, authUi?: AuthU
     await connectWithTimeout(client, transport, `connect ${name}`)
     return client
   }
-  const url = new URL(fill(config.url))
+  // An absent or blank `url` is a server nobody finished configuring, not a malformed
+  // one. `new URL('')` throws "Invalid URL", which reads as a typo in a real address and
+  // sends people looking for one; name the actual state instead.
+  const rawUrl = fill(config.url ?? '').trim()
+  if (rawUrl === '') throw new Error(`${name} is not configured: it has no url`)
+  const url = new URL(rawUrl)
   if (config.type === 'ws' || config.type === 'websocket') {
     // The SDK's WebSocket transport takes only a url: it carries no headers, bearer
     // token, or headersHelper output. Warn rather than silently dropping configured

package/extensions/skills.ts

@@ -39,6 +39,13 @@ import { errorMessage, isDirectory, isRecord } from './internal/values.js'
  * directory is included only for approved projects: pi's loader surfaces every skill's
  * name and description to the model, so an untrusted repository would otherwise get
  * text into the prompt without the user ever agreeing to load its config. */
+/** The extra skill directories a manifest declares, as a list. A string is one entry,
+ * a list is itself, anything else declares none. */
+function declaredSkillDirs(declared: unknown): string[] {
+  if (Array.isArray(declared)) return declared.map(String)
+  return typeof declared === 'string' ? [declared] : []
+}
+
 export function skillDirs(cwd: string, home: string, trusted: boolean): string[] {
   // Claude's precedence: enterprise (the skills directory beside the managed
   // settings file) overrides personal, and personal overrides project; discovery
@@ -48,9 +55,20 @@ export function skillDirs(cwd: string, home: string, trusted: boolean): string[]
   // skill by its directory, so a plugin skill registers without Claude's
   // /plugin: prefix; a rename-free approximation, disclosed in the README.
   for (const plugin of installedPlugins(home)) {
-    const declared = plugin.manifest.skills
-    const dirs = Array.isArray(declared) ? declared : [typeof declared === 'string' ? declared : 'skills']
+    // Claude: "Adds to the default: `skills`. The default `skills/` directory is always
+    // scanned, and directories listed in `skills` are loaded alongside it." Treating the
+    // declaration as a replacement silently dropped every skill in the conventional
+    // location. (The reference's one exception, a marketplace entry whose source resolves
+    // to the marketplace root, is a marketplace shape pi-code does not model.)
+    const extra = declaredSkillDirs(plugin.manifest.skills)
+    const dirs = [...extra, 'skills']
     candidates.push(...dirs.map((dir) => pluginComponentPath(plugin, String(dir))).filter((dir): dir is string => dir !== undefined))
+    // NOT SUPPORTED: Claude's single-skill layout, "a plugin that ships exactly one skill
+    // can place SKILL.md directly at the plugin root". skillPaths is handed to pi's own
+    // loader, which owns the layout and looks for <dir>/<name>/SKILL.md; adding the plugin
+    // root here does not surface root/SKILL.md and does start scanning every sibling
+    // directory (hooks/, agents/, commands/) for skills. Supporting it needs a loader that
+    // accepts a directory that IS the skill, which is pi's call, not this extension's.
   }
   // Claude loads skills from every .claude/skills between cwd and the repository
   // root; the list goes nearest-first so findClaudeSkill's first match is the

package/extensions/status-line.ts

@@ -36,7 +36,7 @@ import { claudeEffortLevel } from './internal/effort.js'
 import { readManagedSettings } from './internal/managed-settings.js'
 import { isPlanModeState, PLAN_MODE_CHANNEL } from './internal/plan-mode-state.js'
 import { isProjectApprovedSilently } from './internal/project-approval.js'
-import { repoRoot } from './internal/project-root.js'
+import { gitRoot, repoRoot } from './internal/project-root.js'
 import { readSettingsChain } from './internal/settings-chain.js'
 import { watchSettingsFiles } from './internal/settings-watch.js'
 import { readActiveStyleName, settingsFiles } from './output-styles.js'
@@ -47,7 +47,9 @@ const DEBOUNCE_MS = 300
 /** Whether cwd sits in a git worktree: `.git` is a file pointing at the main
  * checkout there, and a directory in an ordinary clone. */
 function isGitWorktree(cwd: string): boolean {
-  const root = repoRoot(cwd)
+  // gitRoot, not repoRoot: repoRoot resolves a worktree to its main checkout, which is
+  // exactly the thing this needs to see before it is resolved away.
+  const root = gitRoot(cwd)
   if (root === undefined) return false
   try {
     return fs.statSync(path.join(root, '.git')).isFile()
@@ -350,8 +352,10 @@ export default function statusLine(pi: ExtensionAPI) {
       // Everything below can touch ctx after an await, and every ctx getter throws
       // once the session is disposed. This promise is started from a timer with no
       // awaiter, so an escaping rejection becomes an uncaughtException and exits pi.
-      const result = await runHookCommand(config.command, buildPayload(ctx), COMMAND_TIMEOUT_MS, undefined, undefined, (kill) => {
-        killInflight = kill
+      const result = await runHookCommand(config.command, buildPayload(ctx), COMMAND_TIMEOUT_MS, {
+        onChild: (kill) => {
+          killInflight = kill
+        },
       })
       // Claude: "Your script can output multiple lines to create a richer display."
       // pi has one row for every extension status and replaces newlines with spaces

package/extensions/subagent/index.ts

@@ -56,8 +56,10 @@ export default function subagentExtension(pi: ExtensionAPI) {
 
   const notifyBackgroundCompletion = (run: { id: string; agent: string; state: string; turns: number; output?: string; stderr?: string }): void => {
     // Runs through driveRun's guard, same as the background-mode callback above.
-    // The stop event fires here too, so SubagentStop hooks see resumed runs end.
-    pi.events.emit(SUBAGENT_CHANNEL, { phase: 'stop', agentType: run.agent, agentId: run.id })
+    // The stop event fires here too, so SubagentStop hooks see resumed runs end, and it
+    // carries the run's final assistant text: docs/subagents.md states SubagentStop
+    // receives last_assistant_message unconditionally, and a resumed run is no exception.
+    pi.events.emit(SUBAGENT_CHANNEL, { phase: 'stop', agentType: run.agent, agentId: run.id, lastAssistantMessage: run.output })
     pi.sendMessage({ customType: 'subagent-background', content: backgroundCompletionText(run), display: true }, { triggerTurn: true })
   }
 

package/extensions/thinking.ts

@@ -23,15 +23,21 @@ export function thinkingRank(level: ThinkingLevel): number {
   return Math.max(i, 0)
 }
 
-/** The reasoning level a prompt requests through Claude's think keywords, or undefined
- * when it names none. Checked most-specific first so `think harder` does not fall
- * through to the bare-`think` branch, and on word boundaries so `rethink`/`thinking`
- * and the whole word `ultrathink` never trip the bare match. */
+/** The reasoning level a prompt requests, or undefined when it names none.
+ *
+ * `ultrathink` is the only keyword, per Claude: "Include `ultrathink` anywhere in your
+ * prompt to request deeper reasoning on that turn ... Claude Code passes other phrases
+ * such as 'think', 'think hard', and 'think more' through as ordinary prompt text and
+ * doesn't recognize them as keywords." Escalating on those surprised anyone who merely
+ * used the word in a sentence. Matched on a word boundary so `rethink` and `thinking`
+ * never trip it.
+ *
+ * Divergence: Claude adds an in-context instruction and leaves the API effort level
+ * unchanged. pi has no separate in-context channel for this, and its thinking level IS
+ * how deeper reasoning is requested, so the keyword raises the level for the turn and
+ * restores it after. Same intent, the only mechanism pi has. */
 export function requestedThinkingLevel(text: string): ThinkingLevel | undefined {
-  if (/\bultrathink\b/i.test(text)) return 'max'
-  if (/\bthink harder\b/i.test(text) || /\bthink hard\b/i.test(text)) return 'high'
-  if (/\bthink\b/i.test(text)) return 'medium'
-  return undefined
+  return /\bultrathink\b/i.test(text) ? 'max' : undefined
 }
 
 export default function thinkingExtension(pi: ExtensionAPI) {

package/extensions/web.ts

@@ -195,7 +195,45 @@ async function readCapped(response: Response): Promise<string> {
   return text.slice(0, MAX_RAW_CHARS)
 }
 
-async function fetchText(rawUrl: string, transport = httpFetch): Promise<{ text: string; contentType: string }> {
+/** Either the page, or the cross-host redirect Claude reports instead of following. */
+type FetchOutcome = { kind: 'body'; text: string; contentType: string } | { kind: 'redirect'; to: string }
+
+/** Claude upgrades an http URL to https before fetching; the rest of the URL is
+ * untouched, so a caller's path, query and fragment survive. */
+function upgradeToHttps(rawUrl: string): string {
+  const url = new URL(rawUrl)
+  if (url.protocol === 'http:') url.protocol = 'https:'
+  return url.href
+}
+
+/** Cross-host redirect policy. `report` is WebFetch's documented behavior; `follow`
+ * keeps the old chase for the internal search fetch, whose endpoint is ours and whose
+ * hops Claude's WebFetch rule does not describe. Stated at every call site rather than
+ * defaulted, so a new caller has to decide which it wants. */
+type CrossHost = 'follow' | 'report'
+
+/** The next hop of a redirect, or the naming result that ends the fetch. Split from
+ * fetchText so the loop reads as request-then-hop; every guard the hop needs lives
+ * here. */
+function redirectTarget(response: Response, url: URL, rawUrl: string, crossHost: CrossHost): { kind: 'next'; next: URL } | { kind: 'redirect'; to: string } {
+  // The hop's body is never read; without the cancel its socket stays held
+  // until the 20s abort timeout, once per hop.
+  void response.body?.cancel().catch(() => {})
+  const location = response.headers.get('location')
+  if (!location) throw new Error(`redirect without location from ${url.hostname}`)
+  const next = new URL(location, url)
+  // Only the caller's URL was scheme-checked; a redirect could hand back data: or
+  // file:, which carry no host for the address guard to inspect.
+  if (next.protocol !== 'http:' && next.protocol !== 'https:') throw new Error(`unsupported redirect scheme ${next.protocol} from ${rawUrl}`)
+  // Claude: "When a URL redirects to a different host, WebFetch returns a text
+  // result that names the original URL and the redirect target instead of following
+  // it." The target is never requested, so the per-hop address guard never sees it
+  // and never needs to: a cross-host hop cannot reach anything at all from here.
+  if (crossHost === 'report' && next.hostname.toLowerCase() !== url.hostname.toLowerCase()) return { kind: 'redirect', to: next.href }
+  return { kind: 'next', next }
+}
+
+async function fetchText(rawUrl: string, crossHost: CrossHost, transport = httpFetch): Promise<FetchOutcome> {
   let url = new URL(rawUrl)
   for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
     // Resolve, validate and pin per hop: a redirect target gets the same guarantee.
@@ -206,28 +244,32 @@ async function fetchText(rawUrl: string, transport = httpFetch): Promise<{ text:
       userAgent: USER_AGENT,
     })
     if (response.status >= 300 && response.status < 400) {
-      // The hop's body is never read; without the cancel its socket stays held
-      // until the 20s abort timeout, once per hop.
-      void response.body?.cancel().catch(() => {})
-      const location = response.headers.get('location')
-      if (!location) throw new Error(`redirect without location from ${url.hostname}`)
-      url = new URL(location, url)
-      // Only the caller's URL was scheme-checked; a redirect could hand back data: or
-      // file:, which carry no host for the address guard to inspect.
-      if (url.protocol !== 'http:' && url.protocol !== 'https:') throw new Error(`unsupported redirect scheme ${url.protocol} from ${rawUrl}`)
+      const hop = redirectTarget(response, url, rawUrl, crossHost)
+      if (hop.kind === 'redirect') return hop
+      url = hop.next
       continue
     }
     if (!response.ok) {
       void response.body?.cancel().catch(() => {})
       throw new Error(`HTTP ${response.status} for ${url}`)
     }
-    return { text: await readCapped(response), contentType: response.headers.get('content-type') ?? '' }
+    return { kind: 'body', text: await readCapped(response), contentType: response.headers.get('content-type') ?? '' }
   }
   throw new Error(`too many redirects for ${rawUrl}`)
 }
 
-/** Claude documents a 15-minute per-URL cache for WebFetch. */
-const FETCH_CACHE_TTL_MS = 15 * 60 * 1000
+/** Claude documents a 15-minute per-URL cache for WebFetch, overridable by env:
+ * "set CLAUDE_CODE_WEBFETCH_CACHE_TTL_MS to change how long WebFetch keeps each
+ * response". Read per store so a change takes effect without a restart; an unset,
+ * blank, negative or non-numeric value keeps the documented default. */
+const FETCH_CACHE_TTL_DEFAULT_MS = 15 * 60 * 1000
+
+function fetchCacheTtlMs(): number {
+  const raw = process.env.CLAUDE_CODE_WEBFETCH_CACHE_TTL_MS
+  if (raw === undefined || raw.trim() === '') return FETCH_CACHE_TTL_DEFAULT_MS
+  const parsed = Number(raw)
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : FETCH_CACHE_TTL_DEFAULT_MS
+}
 const FETCH_CACHE_MAX_ENTRIES = 50
 
 type FetchCache = Map<string, { expires: number; body: string }>
@@ -245,7 +287,7 @@ function rememberFetch(cache: FetchCache, url: string, body: string, now: number
     const oldest = cache.keys().next().value
     if (oldest !== undefined) cache.delete(oldest)
   }
-  cache.set(url, { expires: now + FETCH_CACHE_TTL_MS, body })
+  cache.set(url, { expires: now + fetchCacheTtlMs(), body })
 }
 
 /** Claude's WebFetch runs the prompt over the page with a fast model and returns
@@ -278,7 +320,8 @@ export default function webExtension(pi: ExtensionAPI) {
     }),
     async execute(_id, params) {
       // Claude documents allowed/blocked domains as mutually exclusive; allowed wins.
-      const { text } = await fetchText(SEARCH_ENDPOINT + encodeURIComponent(params.query))
+      const outcome = await fetchText(SEARCH_ENDPOINT + encodeURIComponent(params.query), 'follow')
+      const text = outcome.kind === 'body' ? outcome.text : ''
       const limit = Math.min(params.count ?? 5, 10)
       const results = filterByDomain(parseSearchResults(text, 10), params.allowed_domains, params.blocked_domains).slice(0, limit)
       if (results.length === 0) {
@@ -292,7 +335,8 @@ export default function webExtension(pi: ExtensionAPI) {
   pi.registerTool({
     name: 'web_fetch',
     label: 'Web fetch',
-    description: 'Fetch a URL and return its content converted to markdown. Pass `prompt` to get a focused answer extracted from the page instead of the raw content. Responses are cached for 15 minutes per URL.',
+    description:
+      'Fetch a URL and return its content converted to markdown. Pass `prompt` to get a focused answer extracted from the page instead of the raw content. http URLs are upgraded to https, a redirect to a different host is reported rather than followed, and responses are cached per URL for 15 minutes by default (CLAUDE_CODE_WEBFETCH_CACHE_TTL_MS).',
     parameters: Type.Object({
       url: Type.String({ description: 'Absolute http(s) URL to fetch' }),
       prompt: Type.Optional(Type.String({ description: 'What to extract or answer from the page; returns the model’s answer instead of the raw markdown' })),
@@ -301,17 +345,26 @@ export default function webExtension(pi: ExtensionAPI) {
       if (!/^https?:\/\//.test(params.url)) {
         return { content: [{ type: 'text' as const, text: 'Only http(s) URLs are supported.' }], details: {} }
       }
+      // Claude: "HTTP URLs are automatically upgraded to HTTPS." Upgrading here rather
+      // than inside the fetch keeps one spelling for the cache key and the prompt text
+      // too, so http:// and https:// of the same page share a single entry.
+      const target = upgradeToHttps(params.url)
       const now = Date.now()
       // The cache holds the raw markdown, so a second fetch with a different prompt
       // still reuses it: retrieval and the optional prompt step are separate.
-      const cached = fetchCache.get(params.url)
+      const cached = fetchCache.get(target)
       let body: string
       if (cached && cached.expires > now) {
         body = cached.body
       } else {
-        const { text, contentType } = await fetchText(params.url)
-        body = capFetchChars(contentType.includes('html') ? htmlToMarkdown(text) : text)
-        rememberFetch(fetchCache, params.url, body, now)
+        const outcome = await fetchText(target, 'report')
+        // A cross-host redirect has no body to cache or summarize: the naming result is
+        // the answer, and Claude fetches the target with a second call if it wants it.
+        if (outcome.kind === 'redirect') {
+          return { content: [{ type: 'text' as const, text: `${target} redirects to a different host: ${outcome.to}\nFetch ${outcome.to} directly to read it.` }], details: {} }
+        }
+        body = capFetchChars(outcome.contentType.includes('html') ? htmlToMarkdown(outcome.text) : outcome.text)
+        rememberFetch(fetchCache, target, body, now)
       }
 
       // Best-effort prompt-over-page: a failure returns null, so web_fetch always
@@ -319,7 +372,7 @@ export default function webExtension(pi: ExtensionAPI) {
       // usage rides on the result either way, so pi counts it in session totals.
       let usage: Usage | undefined
       if (params.prompt && ctx?.model) {
-        const answer = await answerFromPage(ctx.model, params.prompt, params.url, body, signal)
+        const answer = await answerFromPage(ctx.model, params.prompt, target, body, signal)
         if (answer?.text) return { content: [{ type: 'text' as const, text: answer.text }], details: {}, usage: answer.usage }
         // An empty answer still cost the completion; the fallback carries its usage.
         usage = answer?.usage

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-code",
-  "version": "1.0.60",
+  "version": "1.0.62",
   "description": "Claude Code experience for the pi coding agent: reads your .claude config (rules, commands, skills, hooks, output styles, MCP servers, agents) and adds todo, checkpoints, memory, web, subagents, and goals",
   "keywords": [
     "pi",