@gajae-code/coding-agent 0.7.0 → 0.7.2

package/dist/types/web/insane/bridge.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Bridge from TypeScript to the vendored insane-search Python engine.
+ *
+ * Invokes `python3 -m engine "<url>" --json` per fallback attempt (cwd + PYTHONPATH
+ * pointed at the vendored engine), validates the JSON envelope, and maps it onto a
+ * discriminated result. Hardened: clamped timeout, AbortSignal propagation that
+ * kills+reaps the child, bounded stdout/stderr capture, and a per-process
+ * concurrency cap so blocked reads cannot fork-storm.
+ *
+ * Fail-closed: missing dependencies / bad output / auth-required never throw past
+ * the caller and never auto-install anything; they return ok:false with a stable,
+ * bounded note so `read` can continue with its normal degraded result.
+ */
+import { spawn as nodeSpawn } from "node:child_process";
+/** packages/coding-agent/vendor/insane-search */
+export declare const INSANE_VENDOR_DIR: string;
+/** Stable note prefixes — tests assert on these without depending on full stderr. */
+export declare const INSANE_NOTES: {
+    readonly guardBlocked: (reason: string) => string;
+    readonly vendorMissing: `insane fallback unavailable: vendor engine missing at packages/coding-agent/vendor/insane-search`;
+    readonly noPython: `insane fallback unavailable: python3 not found; install python3 and curl_cffi, then retry with web.insaneFallback=true`;
+    readonly noCurlCffi: `insane fallback unavailable: python3 cannot import curl_cffi; install curl_cffi for Phase 0-2`;
+    readonly noBrowser: `insane fallback unavailable: node/playwright/stealth dependencies missing for Phase 3; install dependencies under packages/coding-agent/vendor/insane-search/engine/templates`;
+    readonly timeout: (seconds: number) => string;
+    readonly invalidJson: `insane fallback failed: engine returned invalid JSON`;
+    readonly authRequired: `insane fallback stopped: authentication required`;
+    readonly verdict: (verdict: string) => string;
+    readonly untried: (routes: string) => string;
+    readonly mustBrowserMcp: `insane fallback requires browser MCP/manual phase: must_invoke_playwright_mcp=true`;
+    readonly concurrency: `insane fallback skipped: max concurrent engine attempts reached`;
+    readonly emptyContent: `insane fallback failed: engine reported ok but returned no content`;
+};
+/** Raw JSON envelope produced by `python3 -m engine --json`. */
+export interface InsaneFetchResultRaw {
+    ok?: boolean;
+    verdict?: string;
+    content?: string;
+    profile_used?: string;
+    trace?: unknown;
+    untried_routes?: string[];
+    must_invoke_playwright_mcp?: boolean;
+}
+export interface InsaneSuccess {
+    ok: true;
+    content: string;
+    profileUsed?: string;
+    notes: string[];
+}
+export interface InsaneFailure {
+    ok: false;
+    reason: string;
+    verdict?: string;
+    notes: string[];
+}
+export type InsaneBridgeResult = InsaneSuccess | InsaneFailure;
+export interface EngineInvocation {
+    url: string;
+    timeoutMs: number;
+    signal?: AbortSignal;
+}
+export interface EngineRawOutput {
+    code: number | null;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+    aborted: boolean;
+}
+/** Seam: run the engine subprocess. Default spawns python3. */
+export type EngineRunner = (inv: EngineInvocation) => Promise<EngineRawOutput>;
+export interface InsaneDependencyStatus {
+    vendorPresent: boolean;
+    python: boolean;
+    curlCffi: boolean;
+    browser: boolean;
+}
+/** Seam: probe dependencies. Default probes the real environment (cached). */
+export type DependencyProber = () => Promise<InsaneDependencyStatus>;
+type SpawnImpl = typeof nodeSpawn;
+/** Real engine runner: `python3 -m engine "<url>" --json`. */
+export declare function runEngineSubprocess(inv: EngineInvocation, options?: {
+    spawnImpl?: SpawnImpl;
+}): Promise<EngineRawOutput>;
+/** Reset the probe cache between tests so probe state never leaks. */
+export declare function resetInsaneProbeCacheForTest(): void;
+/** Probe (and cache) the insane-search runtime dependencies. */
+export declare function probeInsaneDependencies(): Promise<InsaneDependencyStatus>;
+export declare function resetInsaneConcurrencyForTest(): void;
+export interface TryInsaneFetchOptions {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    concurrencyLimit?: number;
+    /** Seam: dependency prober (default real, cached). */
+    prober?: DependencyProber;
+    /** Seam: engine runner (default real subprocess). */
+    runner?: EngineRunner;
+}
+/**
+ * Attempt to read `url` through the insane-search engine. The caller is
+ * responsible for the opt-in gate, raw-mode skip, and the public-URL guard
+ * (which MUST run before this is called). Never throws; always returns a result.
+ */
+export declare function tryInsaneFetch(url: string, options?: TryInsaneFetchOptions): Promise<InsaneBridgeResult>;
+export {};

package/dist/types/web/insane/url-guard.d.ts

@@ -0,0 +1,22 @@
+export interface PublicUrlAccepted {
+    ok: true;
+    url: URL;
+    addresses: string[];
+}
+export interface PublicUrlRejected {
+    ok: false;
+    reason: string;
+}
+export type PublicUrlResult = PublicUrlAccepted | PublicUrlRejected;
+/** Resolver seam so tests can inject DNS results without real lookups. */
+export type AddressResolver = (hostname: string) => Promise<string[]>;
+/** True for any address that is not a routable public unicast address. */
+export declare function isPrivateOrSpecialAddress(address: string): boolean;
+/**
+ * Validate that `rawUrl` is a public http/https target safe to hand to the
+ * insane-search engine. Resolves DNS names and rejects any that map to a
+ * private/special address. Never throws; returns a discriminated result.
+ */
+export declare function validatePublicHttpUrlForInsane(rawUrl: string, options?: {
+    resolver?: AddressResolver;
+}): Promise<PublicUrlResult>;

package/dist/types/web/search/provider.d.ts

@@ -20,5 +20,22 @@ export declare function looksHostedModelId(modelId: string | undefined): boolean
 export declare function isLocalBaseUrl(baseUrl: string | undefined): boolean;
 export declare function inferNativeProviderFromModel(ctx: ActiveSearchModelContext | undefined): SearchProviderId | undefined;
 export declare function canUseGenericCredentials(authStorage: AuthStorage, ctx: ActiveSearchModelContext | undefined, sessionId?: string, signal?: AbortSignal): Promise<boolean>;
-export declare function shouldTryGenericOpenAICompat(authStorage: AuthStorage, ctx: ActiveSearchModelContext | undefined, sessionId?: string, signal?: AbortSignal): Promise<boolean>;
+/**
+ * Native web-search provider to attempt by reusing the ACTIVE model's own
+ * credentials + baseUrl, dispatched by the model's wire protocol.
+ *
+ * This is the "native search over a proxy" path: when a model is served through
+ * a proxy/custom endpoint, its canonical search credentials (e.g. a dedicated
+ * `anthropic` key, or ChatGPT OAuth for `codex`) are usually absent, but the
+ * credential that authenticates the model itself — stored under the active
+ * provider id and aimed at `ctx.baseUrl` — can drive native web search just as
+ * well. Each provider's `search()` falls back to those active credentials when
+ * its canonical ones are missing.
+ *
+ * Returned ids are matched purely from the wire `api` (+ model-id family where a
+ * native tool only makes sense for that family); the providers themselves fail
+ * closed (and the chain falls through to DuckDuckGo) if the endpoint does not
+ * actually support web search.
+ */
+export declare function activeContextNativeId(ctx: ActiveSearchModelContext | undefined): SearchProviderId | undefined;
 export declare function resolveProviderChain(options: ResolveProviderChainOptions): Promise<SearchProvider[]>;

package/dist/types/web/search/providers/insane.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Insane Search Provider
+ *
+ * Native TypeScript, fail-closed adaptation of the MIT-licensed upstream
+ * fivetaku/insane-search public-route strategy. This ports only safe Phase 0
+ * concepts: deterministic no-auth public endpoints plus route-attempt tracing.
+ *
+ * Deliberately excluded from upstream: TLS impersonation, browser/cookie warming,
+ * CAPTCHA/paywall/login bypasses, credential storage, Playwright automation, and
+ * auto dependency installation. Unsupported or terminal auth/paywall/block states
+ * throw instead of pretending a shallow fetch succeeded.
+ */
+import type { AuthStorage } from "@gajae-code/ai";
+import type { SearchResponse, SearchSource } from "../../../web/search/types";
+import type { SearchParams } from "./base";
+import { SearchProvider } from "./base";
+export interface InsaneRouteAttempt {
+    platform: InsanePlatform;
+    route: string;
+    ok: boolean;
+    status: number;
+    bytes: number;
+    note?: string;
+}
+type InsanePlatform = "reddit" | "x" | "youtube" | "hackernews";
+interface RouteSuccess {
+    platform: InsanePlatform;
+    route: string;
+    finalUrl: string;
+    sources: SearchSource[];
+    attempts: InsaneRouteAttempt[];
+}
+interface RouteFailure {
+    platform: InsanePlatform;
+    attempts: InsaneRouteAttempt[];
+}
+type RouteResult = RouteSuccess | RouteFailure | null;
+export declare function routeInsanePublicUrl(rawUrl: string, signal?: AbortSignal): Promise<RouteResult>;
+/** Execute safe Insane Search public-route discovery. */
+export declare function searchInsane(params: {
+    query: string;
+    num_results?: number;
+    recency?: "day" | "week" | "month" | "year";
+    signal?: AbortSignal;
+}): Promise<SearchResponse>;
+/** Keyless provider that ports safe upstream public-route fallbacks only. */
+export declare class InsaneProvider extends SearchProvider {
+    readonly id = "insane";
+    readonly label = "Insane";
+    isAvailable(_authStorage: AuthStorage): boolean;
+    search(params: SearchParams): Promise<SearchResponse>;
+}
+export {};

package/dist/types/web/search/providers/text-citations.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Inline citation extraction shared by native web-search providers.
+ *
+ * Web-search-capable models sometimes return a genuinely grounded answer whose
+ * sources are written inline (markdown links or bare URLs) instead of as
+ * structured citation annotations. When a provider has independent proof that a
+ * web search actually ran, these helpers recover sources from the answer text so
+ * the result is not discarded.
+ */
+import type { SearchSource } from "../types";
+/** Append a source, de-duplicating by URL. */
+export declare function addSource(sources: SearchSource[], source: SearchSource): void;
+/**
+ * Strips prose punctuation and unmatched closing delimiters from extracted URLs.
+ * Models often return links embedded in markdown or sentence text.
+ */
+export declare function normalizeExtractedUrl(candidate: string): string | null;
+/**
+ * Extracts citation sources from markdown links and bare URLs in answer text.
+ * Used only as a fallback when a provider confirms a search ran but omits
+ * structured citation annotations.
+ */
+export declare function extractTextSources(text: string): SearchSource[];

package/dist/types/web/search/types.d.ts

@@ -4,7 +4,7 @@
  * Unified types for web search responses across supported providers.
  */
 /** Supported web search providers */
-export type SearchProviderId = "duckduckgo" | "exa" | "brave" | "jina" | "kimi" | "zai" | "anthropic" | "perplexity" | "gemini" | "codex" | "xai" | "tavily" | "parallel" | "kagi" | "synthetic" | "searxng" | "openai-compatible";
+export type SearchProviderId = "duckduckgo" | "insane" | "exa" | "brave" | "jina" | "kimi" | "zai" | "anthropic" | "perplexity" | "gemini" | "codex" | "xai" | "tavily" | "parallel" | "kagi" | "synthetic" | "searxng" | "openai-compatible";
 export type WebSearchMode = "on" | "off" | "auto";
 export interface ActiveSearchModelContext {
     provider: string;
@@ -15,7 +15,7 @@ export interface ActiveSearchModelContext {
     headers?: Record<string, string>;
     webSearch?: WebSearchMode;
 }
-export declare const CONFIGURABLE_SEARCH_PROVIDER_IDS: readonly ["duckduckgo", "exa", "brave", "jina", "kimi", "zai", "anthropic", "perplexity", "gemini", "codex", "xai", "tavily", "parallel", "kagi", "synthetic", "searxng"];
+export declare const CONFIGURABLE_SEARCH_PROVIDER_IDS: readonly ["duckduckgo", "insane", "exa", "brave", "jina", "kimi", "zai", "anthropic", "perplexity", "gemini", "codex", "xai", "tavily", "parallel", "kagi", "synthetic", "searxng"];
 export declare function isSearchProviderId(value: string): value is SearchProviderId;
 export declare function isConfigurableSearchProviderId(value: string): value is (typeof CONFIGURABLE_SEARCH_PROVIDER_IDS)[number];
 export declare function isSearchProviderPreference(value: string): value is (typeof CONFIGURABLE_SEARCH_PROVIDER_IDS)[number] | "auto";
@@ -96,6 +96,14 @@ export interface AnthropicCitation {
     cited_text: string;
     encrypted_index: string;
 }
+/**
+ * Error payload returned in `web_search_tool_result.content` when a server-side
+ * web search fails. Unlike the success case, this is an object, not an array.
+ */
+export interface AnthropicWebSearchToolResultError {
+    type: "web_search_tool_result_error";
+    error_code?: string;
+}
 export interface AnthropicContentBlock {
     type: string;
     /** Text content (for type="text") */
@@ -108,8 +116,8 @@ export interface AnthropicContentBlock {
     input?: {
         query: string;
     };
-    /** Search results (for type="web_search_tool_result") */
-    content?: AnthropicSearchResult[];
+    /** Search results array on success, or an error object on failure (type="web_search_tool_result") */
+    content?: AnthropicSearchResult[] | AnthropicWebSearchToolResultError;
 }
 export interface AnthropicApiResponse {
     id: string;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.7.0",
+	"version": "0.7.2",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gaebal-gajae.dev",
 	"author": "Yeachan-Heo",
@@ -45,18 +45,19 @@
 		"generate-docs-index": "bun scripts/generate-docs-index.ts",
 		"prepack": "bun scripts/generate-docs-index.ts",
 		"generate-template": "bun scripts/generate-template.ts",
-		"install:defaults": "bun src/cli.ts setup defaults"
+		"install:defaults": "bun src/cli.ts setup defaults",
+		"verify:insane-vendor": "bun scripts/verify-insane-vendor.ts"
 	},
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.7.0",
-		"@gajae-code/agent-core": "0.7.0",
-		"@gajae-code/ai": "0.7.0",
-		"@gajae-code/natives": "0.7.0",
-		"@gajae-code/tui": "0.7.0",
-		"@gajae-code/utils": "0.7.0",
+		"@gajae-code/stats": "0.7.2",
+		"@gajae-code/agent-core": "0.7.2",
+		"@gajae-code/ai": "0.7.2",
+		"@gajae-code/natives": "0.7.2",
+		"@gajae-code/tui": "0.7.2",
+		"@gajae-code/utils": "0.7.2",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",
@@ -84,6 +85,7 @@
 		"examples",
 		"README.md",
 		"CHANGELOG.md",
+		"vendor",
 		"dist/types"
 	],
 	"exports": {

package/scripts/verify-insane-vendor.ts

@@ -0,0 +1,132 @@
+#!/usr/bin/env bun
+/**
+ * Vendor verification for packages/coding-agent/vendor/insane-search.
+ *
+ * Asserts:
+ *   1. Forbidden upstream paths/patterns are absent (install hooks, star-baiting,
+ *      update-notifier, transcript-language scanner, .claude-plugin).
+ *   2. MANIFEST.json exists and pins a full 40-char upstream commit SHA.
+ *   3. The vendored runtime files are present.
+ *   4. `npm pack --dry-run --json` includes the vendor tree (engine entrypoint,
+ *      templates, LICENSE, manifest) in the published package.
+ *
+ * Exit code 0 on success, 1 on any failure.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const pkgDir = join(dirname(fileURLToPath(import.meta.url)), "..");
+const vendorDir = join(pkgDir, "vendor", "insane-search");
+const failures: string[] = [];
+
+function fail(msg: string): void {
+	failures.push(msg);
+}
+
+function walk(dir: string): string[] {
+	const out: string[] = [];
+	for (const entry of readdirSync(dir)) {
+		const full = join(dir, entry);
+		if (statSync(full).isDirectory()) out.push(...walk(full));
+		else out.push(full);
+	}
+	return out;
+}
+
+// 1. Forbidden paths / patterns
+if (!existsSync(vendorDir)) {
+	fail(`vendor tree missing at ${vendorDir}`);
+} else {
+	const files = walk(vendorDir).map(f => relative(vendorDir, f));
+	const forbiddenNames = ["setup.sh", "gptaku-update-check.cjs"];
+	const forbiddenSubpaths = [".claude-plugin/", "/references/", "/tests/coverage_battery"];
+	for (const f of files) {
+		const base = f.split("/").pop() ?? f;
+		if (forbiddenNames.includes(base)) fail(`forbidden file present: ${f}`);
+		for (const sub of forbiddenSubpaths) {
+			if (`/${f}`.includes(sub)) fail(`forbidden path present: ${f}`);
+		}
+	}
+	// Scan for star-baiting / settings.json mutation / transcript scanning patterns.
+	const forbiddenPatterns: Array<[RegExp, string]> = [
+		[/user\/starred/, "github star-baiting (user/starred)"],
+		[/gh\s+api\s+-X\s+PUT/, "gh api star write"],
+		[/SessionStart/, "settings.json SessionStart hook injection"],
+		[/\.claude\/projects/, "past-session transcript scanner"],
+	];
+	for (const f of files) {
+		if (f === "MANIFEST.json") continue; // manifest documents the excluded patterns by name
+		let body = "";
+		try {
+			body = readFileSync(join(vendorDir, f), "utf8");
+		} catch {
+			continue;
+		}
+		for (const [re, label] of forbiddenPatterns) {
+			if (re.test(body)) fail(`forbidden pattern (${label}) found in ${f}`);
+		}
+	}
+}
+
+// 2. Manifest with pinned SHA
+const manifestPath = join(vendorDir, "MANIFEST.json");
+let commit = "";
+if (!existsSync(manifestPath)) {
+	fail("MANIFEST.json missing");
+} else {
+	try {
+		const manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as {
+			upstream?: { commit?: string };
+		};
+		commit = manifest.upstream?.commit ?? "";
+		if (!/^[0-9a-f]{40}$/.test(commit)) fail(`MANIFEST upstream.commit is not a full 40-char SHA: "${commit}"`);
+	} catch (err) {
+		fail(`MANIFEST.json is not valid JSON: ${(err as Error).message}`);
+	}
+}
+
+// 3. Required runtime files present
+const requiredFiles = [
+	"engine/__main__.py",
+	"engine/__init__.py",
+	"engine/fetch_chain.py",
+	"engine/templates/package.json",
+	"engine/templates/playwright_real_chrome.js",
+	"engine/waf_profiles.yaml",
+	"LICENSE",
+	"MANIFEST.json",
+];
+for (const rel of requiredFiles) {
+	if (!existsSync(join(vendorDir, rel))) fail(`required vendored file missing: ${rel}`);
+}
+
+// 4. Package pack inclusion
+try {
+	const raw = execFileSync("npm", ["pack", "--dry-run", "--json"], {
+		cwd: pkgDir,
+		encoding: "utf8",
+		stdio: ["ignore", "pipe", "ignore"],
+	});
+	const parsed = JSON.parse(raw) as Array<{ files?: Array<{ path: string }> }>;
+	const packed = new Set((parsed[0]?.files ?? []).map(f => f.path.replace(/\\/g, "/")));
+	const mustPack = [
+		"vendor/insane-search/engine/__main__.py",
+		"vendor/insane-search/engine/templates/playwright_real_chrome.js",
+		"vendor/insane-search/LICENSE",
+		"vendor/insane-search/MANIFEST.json",
+	];
+	for (const rel of mustPack) {
+		if (!packed.has(rel)) fail(`package pack does not include ${rel}`);
+	}
+} catch (err) {
+	fail(`npm pack --dry-run failed: ${(err as Error).message}`);
+}
+
+if (failures.length > 0) {
+	console.error("insane-vendor verification FAILED:");
+	for (const f of failures) console.error(`  - ${f}`);
+	process.exit(1);
+}
+console.log(`insane-vendor verification passed (pinned ${commit}).`);

package/src/cli/args.ts

@@ -265,7 +265,7 @@ export function getExtraHelpText(): string {
   GJC_SLOW_MODEL              - Override slow/reasoning model (see --slow)
   GJC_PLAN_MODEL              - Override planning model (see --plan)
   GJC_NO_PTY                  - Disable PTY-based interactive bash execution
-  --tmux                       - Launch interactive startup inside a new tmux session
+  --tmux                       - Launch interactive startup inside a fresh tmux session
   gjc session                  - List, inspect, create, remove, or attach tagged GJC-managed tmux sessions
   GJC_LAUNCH_POLICY           - Launch policy for --tmux startup: tmux or direct
   GJC_TMUX_SESSION            - Explicit tmux session name override for --tmux startup

package/src/cli/fast-help.ts

@@ -50,7 +50,7 @@ export function getExtraHelpText(): string {
   GJC_SLOW_MODEL              - Override slow/reasoning model (see --slow)
   GJC_PLAN_MODEL              - Override planning model (see --plan)
   GJC_NO_PTY                  - Disable PTY-based interactive bash execution
-  --tmux                       - Launch interactive startup inside a new tmux session
+  --tmux                       - Launch interactive startup inside a fresh tmux session
   gjc session                  - List, inspect, create, remove, or attach tagged GJC-managed tmux sessions
   GJC_LAUNCH_POLICY           - Launch policy for --tmux startup: tmux or direct
   GJC_TMUX_SESSION            - Explicit tmux session name override for --tmux startup