@liwu1995/afu-context 0.1.5 → 0.1.11

package/bin/host-autoload.py

@@ -13,23 +13,84 @@ from pathlib import Path
 from afu_context import native_install as fs
 from afu_context.diagnostics import state_root
 from afu_context.management import report, validate_policy
+from afu_context.host_command import host_command
+from afu_context.platform_runtime import redirected
+
+
+def node_binary():
+    """The Node.js running this launcher (npx), so Windows needs no PATH lookup."""
+    return os.environ.get("AFU_NODE") or shutil.which("node") or "node"
+
+
+def dsh_command():
+    """argv that starts DSH, plus the path of its real entry script.
+
+    npm installs a POSIX symlink to lib/bin.js, but on Windows a dsh.cmd shim
+    that subprocess cannot run without a shell. Running node on the package's
+    own entry script works on both and needs no shell.
+    """
+    found = shutil.which("dsh")
+    if not found:
+        raise ValueError("dsh is not installed")
+    if not WINDOWS():
+        return [found], os.path.realpath(found)
+    command = host_command(found, "dsh", platform="nt")
+    return command, command[-1]
 
 
 def run(*args, stdin=None):
+    args = [str(a) for a in args]
+    if args and args[0] == "node":
+        args[0] = node_binary()
     result = subprocess.run(
-        args, input=stdin, capture_output=True, text=True, timeout=30
+        args, input=stdin, capture_output=True, text=True, encoding="utf-8" if WINDOWS() else None, timeout=30
     )
     if result.returncode:
         raise ValueError("Host configuration could not be loaded")
     return result.stdout
 
 
+def WINDOWS():
+    return os.name == "nt"
+
+
+def is_link(path):
+    """A symlink, or on Windows a directory junction (both point elsewhere)."""
+    if WINDOWS():
+        return redirected(path)
+    if path.is_symlink():
+        return True
+    is_junction = getattr(path, "is_junction", None)
+    return bool(is_junction and is_junction())
+
+
+def create_junction(target, link):
+    import _winapi
+    # COSEC: native junction API preserves literal paths without cmd expansion.
+    _winapi.CreateJunction(target, link)
+
+
+def link_directory(link, target):
+    """Point link at target. Windows uses a junction: no admin rights needed."""
+    if WINDOWS():
+        create_junction(str(target), str(link))
+        return
+    link.symlink_to(target, target_is_directory=True)
+
+
+def unlink_directory(link):
+    if WINDOWS() and not link.is_symlink():
+        os.rmdir(link)  # Removes the junction itself, never the target files.
+    else:
+        link.unlink()
+
+
 def write_owned(file, content, marker):
     if file.is_symlink():
         raise ValueError("Refusing to replace an extension symlink")
-    if file.exists() and file.read_text() == content:
+    if file.exists() and file.read_text(encoding="utf-8" if WINDOWS() else None) == content:
         return
-    if file.exists() and not file.read_text().startswith(marker):
+    if file.exists() and not file.read_text(encoding="utf-8" if WINDOWS() else None).startswith(marker):
         raise ValueError("Existing extension belongs to another installation")
     fs.atomic(file, content)
 
@@ -53,8 +114,9 @@ def install_pi(root, adapter, settings, previous):
         raise ValueError("Pi extension changed since installation; user file preserved")
     marker = "// Managed by AFU " + root.as_uri() + "\n"
     # The explicit launcher supplies its own extension; avoid installing hooks twice.
-    body = marker + "import register from " + json.dumps(str(adapter)) + ";\n"
-    body += "export default function(pi) {\n if (process.env.AFU_EXPLICIT_EXTENSION === 'pi' || (process.env.AFU_CONTEXT_COMPACT_WORKER_COMMAND && process.argv.some(a => a.endsWith('/afu_host_integrations/pi/dist/index.js')))) return;\n"
+    # A file: URL imports on every OS (a bare "C:\\..." path is not a valid specifier).
+    body = marker + "import register from " + json.dumps(Path(adapter).resolve().as_uri()) + ";\n"
+    body += "export default function(pi) {\n if (process.env.AFU_EXPLICIT_EXTENSION === 'pi' || (process.env.AFU_CONTEXT_COMPACT_WORKER_COMMAND && process.argv.some(a => a.replace(/\\\\/g, '/').endsWith('/afu_host_integrations/pi/dist/index.js')))) return;\n"
     body += (
         " Object.assign(process.env, "
         + json.dumps(settings)
@@ -64,18 +126,17 @@ def install_pi(root, adapter, settings, previous):
     return {"entry": str(entry), "digest": hashlib.sha256(body.encode()).hexdigest()}
 
 
-def profile_manifest(binary, platform, profile):
-    args = [binary, "--profile", profile, "--dump-config"]
-    tree = run(*args)
+def profile_manifest(command, entry, platform, profile):
+    tree = run(*command, "--profile", profile, "--dump-config")
     info = json.loads(
-        run("node", platform / "scripts/dsh-web-probe.mjs", binary, profile)
+        run("node", platform / "scripts/dsh-web-probe.mjs", entry, profile)
     )
     return Path(info["profileDir"]) / "package.json", tree
 
 
 def install_dsh(root, platform, adapter, settings, profile, previous):
-    binary = shutil.which("dsh")
-    manifest, tree = profile_manifest(binary, platform, profile)
+    command, binary = dsh_command()
+    manifest, tree = profile_manifest(command, binary, platform, profile)
     if previous and previous["manifest"] != str(manifest):
         raise ValueError(
             "DSH profile directory changed; existing registration preserved"
@@ -87,15 +148,15 @@ def install_dsh(root, platform, adapter, settings, profile, previous):
     entry = bundle / "provider.mjs"
     link = profile_dir / "node_modules" / bundle_name
     marker = "// Managed by AFU " + root.as_uri() + "\n"
-    original = manifest.read_text()
+    original = manifest.read_text(encoding="utf-8" if WINDOWS() else None)
     config = json.loads(original)
     bundles = config["dsh"]["profile"]["bundles"]
     deps = config.setdefault("dependencies", {})
     owned_dep = "file:" + str(bundle)
-    if link.parent.is_symlink():
+    if is_link(link.parent):
         raise ValueError("Cannot register a bundle in a shared node_modules symlink")
-    if (link.is_symlink() and link.resolve() != bundle) or (
-        link.exists() and not link.is_symlink()
+    if (is_link(link) and link.resolve() != bundle.resolve()) or (
+        link.exists() and not is_link(link)
     ):
         raise ValueError("Existing DSH bundle directory conflicts with AFU")
     if bundle_name in deps and deps[bundle_name] != owned_dep:
@@ -115,8 +176,8 @@ def install_dsh(root, platform, adapter, settings, profile, previous):
         )
         preset = bundle / "presets.mjs"
         if preset.exists():
-            old_arg = ", " + json.dumps(str(bundle)) + ");"
-            source = preset.read_text()
+            old_arg = ", " + json.dumps(str(bundle), ensure_ascii=not WINDOWS()) + ");"
+            source = preset.read_text(encoding="utf-8" if WINDOWS() else None)
             if old_arg not in source:
                 raise ValueError("Unsupported preset loader format")
             cleanup = (
@@ -142,18 +203,20 @@ def install_dsh(root, platform, adapter, settings, profile, previous):
     write_owned(entry, content, marker)
     if not link.exists():
         link.parent.mkdir(parents=True, exist_ok=True)
-        link.symlink_to(bundle, target_is_directory=True)
+        link_directory(link, bundle)
     if bundle_name not in bundles:
         bundles.append(bundle_name)
         deps[bundle_name] = owned_dep
-        if manifest.read_text() != original:
+        if manifest.read_text(encoding="utf-8" if WINDOWS() else None) != original:
             raise ValueError("Concurrent DSH configuration change")
         fs.write(manifest, config)
         try:
-            composed = run(binary, "--profile", profile, "--dump-config")
-            if (
-                str(entry) not in composed
-                and str(bundle / "presets.mjs") not in composed
+            composed = run(*command, "--profile", profile, "--dump-config")
+            # The composed tree may print paths with either separator.
+            flat = composed.replace("\\\\", "/").replace("\\", "/")
+            if not any(
+                (str(p).replace("\\", "/") in flat or (WINDOWS() and p.as_uri() in composed))
+                for p in (entry, bundle / "presets.mjs")
             ):
                 raise ValueError("DSH did not resolve the AFU provider")
         except Exception:
@@ -194,8 +257,8 @@ def remove_record(host, record):
     fs.write(manifest, config)
     # Keep bundle files for running sessions (some presets resolve lazily).
     link = manifest.parent / "node_modules" / name
-    if link.is_symlink() and link.resolve() == Path(record["bundle"]):
-        link.unlink()
+    if is_link(link) and link.resolve() == Path(record["bundle"]).resolve():
+        unlink_directory(link)
 
 
 def main():
@@ -300,6 +363,7 @@ def main():
                     "window": window,
                     "ratio": ratio,
                     "build": fs.read(platform / "release.json")["build"],
+                    "version": fs.read(platform / "release.json").get("version"),
                     "autoload": registrations,
                 },
             )

package/bin/install-guide.mjs

@@ -1,8 +1,31 @@
 import {spawnSync} from 'node:child_process';
-import {accessSync,statSync,constants,mkdirSync,rmSync,mkdtempSync} from 'node:fs';
-import {join,delimiter,resolve} from 'node:path';
+import {accessSync,statSync,constants,mkdirSync,rmSync,mkdtempSync,readFileSync,realpathSync} from 'node:fs';
+import {join,delimiter,resolve,dirname,relative,isAbsolute} from 'node:path';
 import {homedir} from 'node:os';
 import {createInterface} from 'node:readline/promises';
+export function hostCommand(host,env=process.env,platform=process.platform){
+ if(platform!=='win32')return [host];
+ const packages={pi:'@earendil-works/pi-coding-agent',dsh:'@deepseek-ai/dsh'};
+ if(!packages[host])return [host];
+ for(const dir of (env.PATH??env.Path??'').split(delimiter)){
+  for(const ext of ['.exe','.cmd','.bat']){
+   const binary=join(dir,host+ext);
+   try{if(!statSync(binary).isFile())continue;}catch{continue;}
+   if(ext==='.exe')return [binary];
+   const folder=dirname(realpathSync(binary));
+   for(const base of [join(folder,'node_modules',packages[host]),join(folder,'..',packages[host])]){
+    let data;try{data=JSON.parse(readFileSync(join(base,'package.json'),'utf8'));}catch(e){if(e.code==='ENOENT')continue;throw e;}
+    const entry=typeof data.bin==='string'?data.bin:data.bin?.[host];
+    if(data.name!==packages[host]||typeof entry!=='string')continue;
+    const target=realpathSync(resolve(base,entry)),path=relative(realpathSync(base),target);
+    if(path==='..'||path.startsWith('..\\')||path.startsWith('../')||isAbsolute(path)||!statSync(target).isFile())throw Error('INVALID_HOST_ENTRY');
+    return [process.execPath,target];
+   }
+   throw Error('HOST_NPM_ENTRY_UNAVAILABLE');
+  }
+ }
+ throw Error('HOST_EXECUTABLE_UNAVAILABLE');
+}
 export function hostAvailable(host,env=process.env){
  return (env.PATH??env.Path??'').split(delimiter).some(dir=>['',...(process.platform==='win32'?['.exe','.cmd']:[])].some(ext=>{try{accessSync(join(dir,host+ext),constants.X_OK);return statSync(join(dir,host+ext)).isFile();}catch{return false;}}));
 }
@@ -22,7 +45,6 @@ export async function guide(args,env=process.env){
   args=[args[0],host,...args.slice(1)];
  }
  if(!hostAvailable(host,env))throw Error('HOST_NOT_FOUND: '+host);
- if(process.platform==='win32'&&host==='codex')throw Error('WINDOWS_CODEX_NATIVE_UNSUPPORTED');
  const at=args.indexOf('--state');const state=at>=0?resolve(args[at+1]):env.AFU_STATE_DIR??join(homedir(),'.local/share/afu-context');
  mkdirSync(state,{recursive:true,mode:0o700});const check=mkdtempSync(join(state,'.write-check-'));rmSync(check,{recursive:true});
  if(['claude','codex'].includes(host)&&!args.includes('--no-autostart')){

package/bin/platform.mjs

@@ -2,13 +2,13 @@ import {obtainPack} from './prebuilt.mjs';
 import {runInstall} from './install-process.mjs';
 /** Host-only dependencies live outside the installed npm package. */
 import {mkdirSync,readFileSync,writeFileSync,existsSync,rmSync,cpSync,renameSync,realpathSync} from 'node:fs';
-import {join,dirname,delimiter} from 'node:path';
+import {join,dirname,delimiter,basename} from 'node:path';
 import {homedir} from 'node:os';
 
 import {spawnSync} from 'node:child_process';
 import {pathToFileURL} from 'node:url';
 import {randomUUID} from 'node:crypto';
-import {recoverLock} from './runtime.mjs';
+import {recoverLock,importProbeSucceeded} from './runtime.mjs';
 const read=p=>{try{return JSON.parse(readFileSync(p,'utf8'));}catch{return null;}};
 export function npmInvocation(env=process.env,platform=process.platform){
   if(platform!=='win32')return ['npm',[]];
@@ -28,7 +28,7 @@ export async function preparePlatform(root,manifest,args,env=process.env){
   let target=canonical;
   const refresh=()=>{const name=read(pointer)?.name;target=typeof name==='string'&&name.startsWith(manifest.build+'-'+host)&&!/[\\/]/.test(name)?join(base,name):canonical;};
   refresh();
-  const ready=()=>read(join(target,'platform-ready.json'))?.build===manifest.build && Object.keys(dependencies).every(name=>existsSync(join(target,'node_modules',name,'package.json'))) && spawnSync(process.execPath,['--input-type=module','-e','await import(process.argv[1])',pathToFileURL(join(target,'src/afu_host_integrations',host,'dist/index.js')).href],{env,stdio:'ignore',timeout:10000}).status===0;
+  const ready=()=>read(join(target,'platform-ready.json'))?.build===manifest.build && Object.keys(dependencies).every(name=>existsSync(join(target,'node_modules',name,'package.json'))) && importProbeSucceeded(spawnSync(process.execPath,['--input-type=module','-e','await import(process.argv[1])',pathToFileURL(join(target,'src/afu_host_integrations',host,'dist/index.js')).href],{env,stdio:'ignore',timeout:process.platform==='win32'?30000:10000}));
   mkdirSync(base,{recursive:true,mode:0o700});
   const deadline=Date.now()+180000;
   while(true){
@@ -66,7 +66,7 @@ export async function preparePlatform(root,manifest,args,env=process.env){
     // and corrupt transitive dependencies. No model request is made by imports.
     await runInstall(process.execPath,['--input-type=module','-e','await import(process.argv[1])',pathToFileURL(join(target,'src/afu_host_integrations',host,'dist/index.js')).href],env);
     writeFileSync(join(target,'platform-ready.json'),JSON.stringify({build:manifest.build,cache_protocol:1}),{mode:0o600});
-    const temp=pointer+'.'+token;writeFileSync(temp,JSON.stringify({name:target.slice(base.length+1)}),{mode:0o600});renameSync(temp,pointer);return target;
+    const temp=pointer+'.'+token;writeFileSync(temp,JSON.stringify({name:process.platform==='win32'?basename(target):target.slice(base.length+1)}),{mode:0o600});renameSync(temp,pointer);return target;
   }catch(error){
     if(owns()&&createdTarget)rmSync(createdTarget,{recursive:true,force:true});
     throw error;

package/bin/runtime.mjs

@@ -33,12 +33,16 @@ export function recoverLock(lock, now=Date.now()) {
     renameSync(lock,tomb);moved=true;rmSync(tomb,{recursive:true,force:true});return true;
   }catch{return false;}finally{if(!moved)rmSync(guard,{recursive:true,force:true});}
 }
+export function importProbeSucceeded(result,platform=process.platform){
+  if(platform==='win32'&&result.error?.code==='ETIMEDOUT')throw Error('IMPORT_CHECK_TIMED_OUT: existing cache preserved; retry when the machine is less busy');
+  return result.status===0;
+}
 export function runtimeReady(location, build) {
   const marker=read(join(location,'afu-ready.json'));
   const python=join(location,process.platform==='win32'?'Scripts/python.exe':'bin/python');
   if(marker?.build!==build || !existsSync(python))return false;
   // A surviving marker is not proof that imports and the interpreter still work.
-  return spawnSync(python,['-c','import afu_context.local_cli, aiohttp, tiktoken'],{stdio:'ignore',timeout:10000}).status===0;
+  return importProbeSucceeded(spawnSync(python,['-c','import afu_context.local_cli, aiohttp, tiktoken'],{stdio:'ignore',timeout:process.platform==='win32'?30000:10000}));
 }
 export async function prepareRuntime(root,manifest,env=process.env) {
   const base=env.AFU_RUNTIME_DIR ?? join(homedir(),'.local/share/afu-context/runtimes');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liwu1995/afu-context",
-  "version": "0.1.5",
+  "version": "0.1.11",
   "type": "module",
   "license": "Apache-2.0",
   "description": "Local asynchronous context compression and diagnostics",

package/release.json

@@ -1,6 +1,6 @@
 {
-  "version": "0.1.5",
-  "build": "9211426113913a6035cb91ef91d2bdb420342298b4994abf214dbfd0fd1ed521",
-  "wheel": "afu_context_local-0.1.5-py3-none-any.whl",
+  "version": "0.1.11",
+  "build": "00a744986d028b488f3f9a6396bf06cb1983e95e293eeae624f93aab1119377b",
+  "wheel": "afu_context_local-0.1.11-py3-none-any.whl",
   "prebuilt": false
 }

package/scripts/dsh-overlay.mjs

@@ -1,11 +1,16 @@
 /** Compose a disposable overlay using DSH's own YAML and patch semantics. */
 import {readFileSync, writeFileSync, realpathSync} from 'node:fs';
 import {createRequire} from 'node:module';
-import {join} from 'node:path';
+import {join,isAbsolute} from 'node:path';
 import {pathToFileURL} from 'node:url';
 import {load,dump} from 'js-yaml';
 import {entryListSchema,applyEntryPatches} from '@deepseek-ai/cordis-plugin-include';
 
+export function moduleReference(value) {
+  // COSEC: convert only local absolute paths, never reinterpret package names or URLs.
+  return process.platform === 'win32' && isAbsolute(value) ? pathToFileURL(value).href : value;
+}
+
 export function overlay(entries,module,presetModule) {
   if (!Array.isArray(entries)) throw Error('Expected a composed DSH entry list');
   const ids=new Set(), matches=[], presets=[];
@@ -43,10 +48,10 @@ if(process.argv[1] && import.meta.url===pathToFileURL(process.argv[1]).href) {
       try {
         const native=requireHost.resolve('@deepseek-ai/dsh-agent-presets');
         presetModule=join(process.argv[3],'presets.mjs');
-        writeFileSync(presetModule, `import Native from ${JSON.stringify(pathToFileURL(native).href)};\nimport {presetAdapter} from ${JSON.stringify(new URL('./dsh-presets.mjs',import.meta.url).href)};\nexport default presetAdapter(Native, ${JSON.stringify(process.argv[2])}, ${JSON.stringify(process.argv[3])});\n`, {mode:0o600});
+        writeFileSync(presetModule, `import Native from ${JSON.stringify(pathToFileURL(native).href)};\nimport {presetAdapter} from ${JSON.stringify(new URL('./dsh-presets.mjs',import.meta.url).href)};\nexport default presetAdapter(Native, ${JSON.stringify(moduleReference(process.argv[2]))}, ${JSON.stringify(process.argv[3])});\n`, {mode:0o600});
       } catch (error) { if(error.code!=='MODULE_NOT_FOUND') throw error; }
     }
-    const patches=overlay(tree,process.argv[2],presetModule);
+    const patches=overlay(tree,moduleReference(process.argv[2]),presetModule && moduleReference(presetModule));
     if (process.argv[5]==='web-compat') {
       const picker=tree.find(row=>!row.disabled && row.name==='@deepseek-ai/dsh-host-directory-picker-auto');
       if (picker) {

package/src/afu_host_integrations/dsh/dist/index.js

@@ -1,6 +1,6 @@
 import { BasicCompactionEngine, } from "@deepseek-ai/dsh-compaction-basic";
 import { BlockAssembler, createUserMessage } from "@deepseek-ai/dsh-llm";
-import { journal, sessionHash, summaryPrefix, observationId, HostCompactPool, bindingKey, estimateContentTokens, findAppliedArtifact, normalizeContent, } from "../../shared/runtime-client/dist/index.js";
+import { journal, sessionHash, afuTrigger, summaryPrefix, observationId, HostCompactPool, bindingKey, estimateContentTokens, findAppliedArtifact, normalizeContent, } from "../../shared/runtime-client/dist/index.js";
 /**
  * DSH-native compaction provider. Idle turns prepare Compact Artifacts off-path;
  * the next pre-step commits only exact, still-contiguous coverage through DSH's
@@ -48,7 +48,17 @@ export class CompactDshEngine extends BasicCompactionEngine {
         ctx.on("agent/status", async ({ agent, status }) => {
             if (status !== "idle")
                 return;
-            this.log("request_observed", { session: sessionHash(agent.session.id), phase: "host_turn_idle" });
+            // Context size as DSH's own token meter prices it, plus the AFU trigger for the routed model.
+            let tokens, window;
+            tokens = dshContextTokens(ctx, agent);
+            try {
+                window = (await dshHostBinding(ctx, agent, () => this.generation)).contextWindow;
+            }
+            catch {
+                window = undefined;
+            }
+            this.log("request_observed", { session: sessionHash(agent.session.id), phase: "host_turn_idle",
+                ...(tokens === undefined ? {} : { estimated_input_tokens: tokens }), ...afuTrigger(window) });
             try {
                 const request = await this.boundRequest(agent, agent.session.deriveMessages(), "sync");
                 this.idlePrecomputer.schedule(request);
@@ -58,7 +68,9 @@ export class CompactDshEngine extends BasicCompactionEngine {
             }
         });
         ctx.effect(() => async () => {
-            this.log("runtime_stopped");
+            // DSH creates and disposes an engine for every agent scope (the web app
+            // does so per request); the process lives on. runtime_stopped is logged
+            // once, when the process exits (see telemetry.journal).
             // Stop scheduling first so jobs cancelled by shutdown are not reported
             // as preparation failures, then stop the host and let them settle.
             this.idlePrecomputer.stop();
@@ -78,7 +90,9 @@ export class CompactDshEngine extends BasicCompactionEngine {
         if (!this.bindings.has(binding.key) && this.bindings.size >= 16)
             throw new Error("DSH binding limit reached");
         this.bindings.set(binding.key, binding);
-        return dshMessagesToRequest(messages, binding.key, mode);
+        const request = dshMessagesToRequest(messages, binding.key, mode);
+        const tokens = dshContextTokens(this.ctx, agent);
+        return tokens === undefined ? request : { ...request, metadata: { ...request.metadata, host_context_tokens: tokens } };
     }
     async compactIfNeeded(agent, trigger, signal) {
         const started = performance.now();
@@ -234,6 +248,17 @@ export async function dshHostBinding(ctx, agent, generation) {
         },
     };
 }
+/** DSH's own token meter (the measure its native compaction uses), if available. */
+function dshContextTokens(ctx, agent) {
+    try {
+        const meter = ctx.tokenMeter;
+        const tokens = meter?.measure(agent.session).totalTokens;
+        return Number.isSafeInteger(tokens) && tokens > 0 ? tokens : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function dshMessagesToRequest(messages, sessionId, mode = "active") {
     const groups = toolCallGroups(messages);
     const items = messages.map((message) => {