@hienlh/ppm 0.9.30 → 0.9.31

package/src/server/index.ts

@@ -387,8 +387,8 @@ if (process.argv.includes("__serve__")) {
     wf(statusFile, JSON.stringify(status));
     if (status.shareUrl) {
       const { tunnelService } = await import("../services/tunnel.service.ts");
-      tunnelService.setExternalUrl(status.shareUrl);
       if (status.tunnelPid) tunnelService.setExternalPid(status.tunnelPid);
+      tunnelService.setExternalUrl(status.shareUrl);
     }
   } catch { /* status.json missing or no shareUrl — normal */ }
 

package/src/server/routes/proxy.ts

@@ -57,21 +57,6 @@ proxyRoutes.post("/v1/messages", async (c) => {
   return proxyService.forward("/v1/messages", "POST", headers, body);
 });
 
-/** POST /proxy/v1/chat/completions — OpenAI-compatible chat completions proxy */
-proxyRoutes.post("/v1/chat/completions", async (c) => {
-  if (!proxyService.isEnabled()) {
-    return c.json({ error: { message: "Proxy is disabled", type: "server_error" } }, 503);
-  }
-
-  const authHeader = c.req.header("authorization") || c.req.header("x-api-key");
-  if (!validateProxyAuth(authHeader)) {
-    return c.json({ error: { message: "Invalid proxy auth key", type: "authentication_error" } }, 401);
-  }
-
-  const body = await c.req.text();
-  return proxyService.forwardOpenAi(body);
-});
-
 /** POST /proxy/v1/messages/count_tokens — token counting proxy */
 proxyRoutes.post("/v1/messages/count_tokens", async (c) => {
   if (!proxyService.isEnabled()) {

package/src/server/routes/settings.ts

@@ -292,10 +292,8 @@ async function buildProxyResponse() {
     authKey: proxyService.getAuthKey() ?? null,
     requestCount: proxyService.getRequestCount(),
     localEndpoint: `${localOrigin}/proxy/v1/messages`,
-    localOpenAiEndpoint: `${localOrigin}/proxy/v1/chat/completions`,
     tunnelUrl: tunnelUrl ?? null,
     proxyEndpoint: tunnelUrl ? `${tunnelUrl}/proxy/v1/messages` : null,
-    openAiEndpoint: tunnelUrl ? `${tunnelUrl}/proxy/v1/chat/completions` : null,
   };
 }
 

package/src/services/proxy-sdk-bridge.ts

@@ -172,82 +172,40 @@ async function handleStreaming(
 
         // Track tool_use block indices to filter them out
         const skipBlockIndices = new Set<number>();
-        let streamed = false; // track if we sent any SSE events
-        let lastContentLen = 0; // for partial message diff
 
         try {
           for await (const message of response) {
-            const msgType = (message as any).type;
+            if (message.type !== "stream_event") continue;
 
-            // ── stream_event: raw Anthropic SSE events (best quality) ──
-            if (msgType === "stream_event") {
-              const event = (message as any).event;
-              const eventType = event.type as string;
-              const eventIndex = event.index as number | undefined;
+            const event = (message as any).event;
+            const eventType = event.type as string;
+            const eventIndex = event.index as number | undefined;
 
-              if (eventType === "content_block_start" && event.content_block?.type === "tool_use") {
+            // Filter tool_use content blocks — external tools expect text only
+            if (eventType === "content_block_start") {
+              const block = event.content_block;
+              if (block?.type === "tool_use") {
                 if (eventIndex !== undefined) skipBlockIndices.add(eventIndex);
                 continue;
               }
-              if (eventIndex !== undefined && skipBlockIndices.has(eventIndex)) continue;
-
-              if (eventType === "message_delta") {
-                const patched = {
-                  ...event,
-                  delta: { ...(event.delta || {}), stop_reason: "end_turn" },
-                  usage: event.usage || { output_tokens: 0 },
-                };
-                controller.enqueue(encoder.encode(`event: ${eventType}\ndata: ${JSON.stringify(patched)}\n\n`));
-              } else {
-                controller.enqueue(encoder.encode(`event: ${eventType}\ndata: ${JSON.stringify(event)}\n\n`));
-              }
-              streamed = true;
-              continue;
             }
 
-            // ── partial: incremental content (fallback if no stream_event) ──
-            if (msgType === "partial" && !streamed) {
-              const content = (message as any).message?.content ?? [];
-              let fullText = "";
-              for (const block of content) {
-                if (block.type === "text") fullText += block.text ?? "";
-              }
-              const delta = fullText.slice(lastContentLen);
-              if (delta) {
-                // Emit Anthropic SSE envelope on first partial
-                if (lastContentLen === 0) {
-                  const msgStart = { type: "message_start", message: { id: `msg_${Date.now()}`, type: "message", role: "assistant", model: body.model, content: [], stop_reason: null, usage: { input_tokens: 0, output_tokens: 0 } } };
-                  controller.enqueue(encoder.encode(`event: message_start\ndata: ${JSON.stringify(msgStart)}\n\n`));
-                  controller.enqueue(encoder.encode(`event: content_block_start\ndata: ${JSON.stringify({ type: "content_block_start", index: 0, content_block: { type: "text", text: "" } })}\n\n`));
-                }
-                controller.enqueue(encoder.encode(`event: content_block_delta\ndata: ${JSON.stringify({ type: "content_block_delta", index: 0, delta: { type: "text_delta", text: delta } })}\n\n`));
-                lastContentLen = fullText.length;
-              }
+            // Skip deltas and stops for tool_use blocks
+            if (eventIndex !== undefined && skipBlockIndices.has(eventIndex)) continue;
+
+            // Override message_delta to always show end_turn
+            if (eventType === "message_delta") {
+              const patched = {
+                ...event,
+                delta: { ...(event.delta || {}), stop_reason: "end_turn" },
+                usage: event.usage || { output_tokens: 0 },
+              };
+              controller.enqueue(encoder.encode(`event: ${eventType}\ndata: ${JSON.stringify(patched)}\n\n`));
               continue;
             }
 
-            // ── assistant: final complete message (fallback if nothing streamed) ──
-            if (msgType === "assistant" && !streamed && lastContentLen === 0) {
-              const content = (message as any).message?.content ?? [];
-              let fullText = "";
-              for (const block of content) {
-                if (block.type === "text") fullText += block.text ?? "";
-              }
-              if (fullText) {
-                const msgStart = { type: "message_start", message: { id: `msg_${Date.now()}`, type: "message", role: "assistant", model: body.model, content: [], stop_reason: null, usage: { input_tokens: 0, output_tokens: 0 } } };
-                controller.enqueue(encoder.encode(`event: message_start\ndata: ${JSON.stringify(msgStart)}\n\n`));
-                controller.enqueue(encoder.encode(`event: content_block_start\ndata: ${JSON.stringify({ type: "content_block_start", index: 0, content_block: { type: "text", text: "" } })}\n\n`));
-                controller.enqueue(encoder.encode(`event: content_block_delta\ndata: ${JSON.stringify({ type: "content_block_delta", index: 0, delta: { type: "text_delta", text: fullText } })}\n\n`));
-                lastContentLen = fullText.length;
-              }
-            }
-          }
-
-          // Close SSE envelope if we used partial/assistant fallback
-          if (!streamed && lastContentLen > 0) {
-            controller.enqueue(encoder.encode(`event: content_block_stop\ndata: ${JSON.stringify({ type: "content_block_stop", index: 0 })}\n\n`));
-            controller.enqueue(encoder.encode(`event: message_delta\ndata: ${JSON.stringify({ type: "message_delta", delta: { stop_reason: "end_turn" }, usage: { output_tokens: 0 } })}\n\n`));
-            controller.enqueue(encoder.encode(`event: message_stop\ndata: ${JSON.stringify({ type: "message_stop" })}\n\n`));
+            // Forward all other events (message_start, text deltas, content_block_start/stop, message_stop)
+            controller.enqueue(encoder.encode(`event: ${eventType}\ndata: ${JSON.stringify(event)}\n\n`));
           }
 
           accountSelector.onSuccess(account.id);

package/src/services/proxy.service.ts

@@ -2,7 +2,6 @@ import { getConfigValue, setConfigValue } from "./db.service.ts";
 import { accountSelector } from "./account-selector.service.ts";
 import { accountService } from "./account.service.ts";
 import { forwardViaSdk } from "./proxy-sdk-bridge.ts";
-import { forwardOpenAiViaSdk } from "./proxy-openai-bridge.ts";
 import { randomBytes } from "node:crypto";
 
 const PROXY_ENABLED_KEY = "proxy_enabled";
@@ -87,38 +86,6 @@ class ProxyService {
     return this.forwardDirect(path, method, headers, body, token, account);
   }
 
-  /**
-   * Forward an OpenAI-format chat completions request via SDK query().
-   * Always uses SDK bridge (works for both OAuth and API key accounts).
-   */
-  async forwardOpenAi(body: string): Promise<Response> {
-    const account = accountSelector.next();
-    if (!account) {
-      return new Response(
-        JSON.stringify({ error: { message: "No active accounts available", type: "server_error" } }),
-        { status: 401, headers: { "Content-Type": "application/json" } },
-      );
-    }
-
-    let token = account.accessToken;
-    if (token.startsWith("sk-ant-oat")) {
-      const fresh = await accountService.ensureFreshToken(account.id);
-      if (fresh) token = fresh.accessToken;
-    }
-
-    try {
-      const parsed = JSON.parse(body);
-      this.requestCount++;
-      return await forwardOpenAiViaSdk(parsed, { id: account.id, email: account.email, accessToken: token });
-    } catch (e) {
-      console.error(`[proxy] OpenAI bridge error:`, (e as Error).message);
-      return new Response(
-        JSON.stringify({ error: { message: (e as Error).message, type: "server_error" } }),
-        { status: 502, headers: { "Content-Type": "application/json" } },
-      );
-    }
-  }
-
   /** Direct HTTP forward for API key accounts */
   private async forwardDirect(
     path: string,

package/src/services/supervisor.ts

@@ -9,6 +9,7 @@ import { resolve } from "node:path";
 import { homedir } from "node:os";
 import {
   readFileSync, writeFileSync, existsSync, mkdirSync, openSync, appendFileSync,
+  unlinkSync,
 } from "node:fs";
 import { isCompiledBinary } from "./autostart-generator.ts";
 
@@ -30,6 +31,7 @@ const PPM_DIR = resolve(process.env.PPM_HOME || resolve(homedir(), ".ppm"));
 const STATUS_FILE = resolve(PPM_DIR, "status.json");
 const PID_FILE = resolve(PPM_DIR, "ppm.pid");
 const LOG_FILE = resolve(PPM_DIR, "ppm.log");
+const RESTARTING_FLAG = resolve(PPM_DIR, ".restarting");
 
 // ─── State ─────────────────────────────────────────────────────────────
 let serverChild: Subprocess | null = null;
@@ -417,6 +419,9 @@ async function selfReplace(): Promise<{ success: boolean; error?: string }> {
     supervisorState = "upgrading";
     updateStatus({ state: "upgrading" });
 
+    // Set restarting flag so server child's stopTunnel() skips killing the tunnel
+    try { writeFileSync(RESTARTING_FLAG, ""); } catch {}
+
     // Kill server child to free the port; keep tunnel alive for domain continuity
     log("INFO", "Stopping server before spawning new supervisor (tunnel kept alive)");
     if (serverChild) { try { serverChild.kill(); } catch {} serverChild = null; }
@@ -456,6 +461,7 @@ async function selfReplace(): Promise<{ success: boolean; error?: string }> {
     // Timeout — new supervisor didn't start, restore old supervisor
     log("ERROR", "Self-replace timeout: new supervisor did not start");
     try { child.kill(); } catch {}
+    try { unlinkSync(RESTARTING_FLAG); } catch {}
     shuttingDown = false;
     notifyStateChange("upgrading", "running", "upgrade_failed");
     supervisorState = "running";
@@ -463,6 +469,7 @@ async function selfReplace(): Promise<{ success: boolean; error?: string }> {
     return { success: false, error: "New supervisor failed to start within 30s" };
   } catch (e) {
     log("ERROR", `Self-replace error: ${e}`);
+    try { unlinkSync(RESTARTING_FLAG); } catch {}
     shuttingDown = false;
     notifyStateChange("upgrading", "running", "upgrade_failed");
     supervisorState = "running";
@@ -631,6 +638,9 @@ export async function runSupervisor(opts: {
 }) {
   if (!existsSync(PPM_DIR)) mkdirSync(PPM_DIR, { recursive: true });
 
+  // Clean up restarting flag from previous upgrade/restart
+  try { unlinkSync(RESTARTING_FLAG); } catch {}
+
   // Save original argv for self-replace
   originalArgv = [...process.argv];
 

package/src/web/components/settings/proxy-settings-section.tsx

@@ -134,43 +134,43 @@ export function ProxySettingsSection() {
             <ProxyTestButton authKey={settings.authKey!} baseUrl={window.location.origin} />
           </div>
 
-          {/* Anthropic endpoint */}
+          {/* Local endpoint */}
           <div className="space-y-1">
-            <Label className="text-[10px] text-muted-foreground">Anthropic Endpoint</Label>
+            <Label className="text-[10px] text-muted-foreground">Local Endpoint</Label>
             <div className="flex gap-1.5 items-center">
               <code className="text-[10px] font-mono bg-muted px-1.5 py-0.5 rounded flex-1 truncate">
-                {hasTunnel ? settings.proxyEndpoint : localEndpoint}
+                {localEndpoint}
               </code>
               <Button
                 variant="ghost"
                 size="sm"
                 className="h-6 px-1.5 cursor-pointer shrink-0"
-                onClick={() => copyToClipboard(hasTunnel ? settings.proxyEndpoint! : localEndpoint, "anthropic")}
+                onClick={() => copyToClipboard(localEndpoint, "local")}
               >
-                {copied === "anthropic" ? "Copied!" : <Copy className="size-3" />}
+                {copied === "local" ? "Copied!" : <Copy className="size-3" />}
               </Button>
             </div>
           </div>
 
-          {/* OpenAI endpoint */}
-          <div className="space-y-1">
-            <Label className="text-[10px] text-muted-foreground">OpenAI-Compatible Endpoint</Label>
-            <div className="flex gap-1.5 items-center">
-              <code className="text-[10px] font-mono bg-muted px-1.5 py-0.5 rounded flex-1 truncate">
-                {hasTunnel ? settings.openAiEndpoint : settings.localOpenAiEndpoint}
-              </code>
-              <Button
-                variant="ghost"
-                size="sm"
-                className="h-6 px-1.5 cursor-pointer shrink-0"
-                onClick={() => copyToClipboard(
-                  hasTunnel ? settings.openAiEndpoint! : settings.localOpenAiEndpoint, "openai",
-                )}
-              >
-                {copied === "openai" ? "Copied!" : <Copy className="size-3" />}
-              </Button>
+          {/* Tunnel endpoint */}
+          {hasTunnel && settings.proxyEndpoint && (
+            <div className="space-y-1">
+              <Label className="text-[10px] text-muted-foreground">Public Endpoint (Tunnel)</Label>
+              <div className="flex gap-1.5 items-center">
+                <code className="text-[10px] font-mono bg-muted px-1.5 py-0.5 rounded flex-1 truncate">
+                  {settings.proxyEndpoint}
+                </code>
+                <Button
+                  variant="ghost"
+                  size="sm"
+                  className="h-6 px-1.5 cursor-pointer shrink-0"
+                  onClick={() => copyToClipboard(settings.proxyEndpoint!, "tunnel")}
+                >
+                  {copied === "tunnel" ? "Copied!" : <Copy className="size-3" />}
+                </Button>
+              </div>
             </div>
-          </div>
+          )}
 
           {!hasTunnel && (
             <p className="text-[10px] text-muted-foreground">
@@ -178,13 +178,21 @@ export function ProxySettingsSection() {
             </p>
           )}
 
-          {/* Usage examples */}
+          {/* Usage example */}
           <div className="space-y-1 pt-1">
-            <Label className="text-[10px] text-muted-foreground">Anthropic Format</Label>
+            <Label className="text-[10px] text-muted-foreground">Usage Example</Label>
             <div className="relative">
               <pre className="text-[9px] font-mono bg-muted p-2 rounded overflow-x-auto whitespace-pre">
-{`ANTHROPIC_BASE_URL=${hasTunnel ? settings.tunnelUrl + "/proxy" : localBaseUrl + "/proxy"}
-ANTHROPIC_API_KEY=${settings.authKey}`}
+{`# Set as base URL in your tool
+ANTHROPIC_BASE_URL=${hasTunnel ? settings.tunnelUrl + "/proxy" : localBaseUrl + "/proxy"}
+ANTHROPIC_API_KEY=${settings.authKey}
+
+# Or use curl
+curl ${hasTunnel ? settings.proxyEndpoint : localEndpoint} \\
+  -H "x-api-key: ${settings.authKey}" \\
+  -H "content-type: application/json" \\
+  -H "anthropic-version: 2023-06-01" \\
+  -d '{"model":"claude-sonnet-4-6","max_tokens":1024,"messages":[{"role":"user","content":"Hello"}]}'`}
               </pre>
               <Button
                 variant="ghost"
@@ -192,31 +200,10 @@ ANTHROPIC_API_KEY=${settings.authKey}`}
                 className="absolute top-1 right-1 h-5 px-1 cursor-pointer"
                 onClick={() => copyToClipboard(
                   `ANTHROPIC_BASE_URL=${hasTunnel ? settings.tunnelUrl + "/proxy" : localBaseUrl + "/proxy"}\nANTHROPIC_API_KEY=${settings.authKey}`,
-                  "anthropic-env",
-                )}
-              >
-                {copied === "anthropic-env" ? "Copied!" : <Copy className="size-2.5" />}
-              </Button>
-            </div>
-          </div>
-
-          <div className="space-y-1">
-            <Label className="text-[10px] text-muted-foreground">OpenAI Format</Label>
-            <div className="relative">
-              <pre className="text-[9px] font-mono bg-muted p-2 rounded overflow-x-auto whitespace-pre">
-{`OPENAI_BASE_URL=${hasTunnel ? settings.tunnelUrl + "/proxy/v1" : localBaseUrl + "/proxy/v1"}
-OPENAI_API_KEY=${settings.authKey}`}
-              </pre>
-              <Button
-                variant="ghost"
-                size="sm"
-                className="absolute top-1 right-1 h-5 px-1 cursor-pointer"
-                onClick={() => copyToClipboard(
-                  `OPENAI_BASE_URL=${hasTunnel ? settings.tunnelUrl + "/proxy/v1" : localBaseUrl + "/proxy/v1"}\nOPENAI_API_KEY=${settings.authKey}`,
-                  "openai-env",
+                  "example",
                 )}
               >
-                {copied === "openai-env" ? "Copied!" : <Copy className="size-2.5" />}
+                {copied === "example" ? "Copied!" : <Copy className="size-2.5" />}
               </Button>
             </div>
           </div>

package/src/web/components/settings/proxy-test-section.tsx

@@ -45,7 +45,6 @@ function ProxyTestForm({ authKey, baseUrl }: ProxyTestDialogProps) {
   const [format, setFormat] = useState<EndpointFormat>("anthropic");
   const [message, setMessage] = useState(DEFAULT_MESSAGE);
   const [model, setModel] = useState(DEFAULT_MODEL);
-  const [streaming, setStreaming] = useState(true);
   const [testing, setTesting] = useState(false);
   const [output, setOutput] = useState<string | null>(null);
   const [error, setError] = useState<string | null>(null);
@@ -66,6 +65,9 @@ function ProxyTestForm({ authKey, baseUrl }: ProxyTestDialogProps) {
     setElapsed(null);
   };
 
+  // Both formats hit the same proxy endpoint — only request/response shape differs
+  const endpoint = `${baseUrl}/proxy/v1/messages`;
+
   const runTest = async () => {
     setTesting(true);
     setOutput(null);
@@ -73,19 +75,21 @@ function ProxyTestForm({ authKey, baseUrl }: ProxyTestDialogProps) {
     setElapsed(null);
     const start = Date.now();
 
-    const isOpenAi = format === "openai";
-    const endpoint = isOpenAi
-      ? `${baseUrl}/proxy/v1/chat/completions`
-      : `${baseUrl}/proxy/v1/messages`;
-
-    const body = JSON.stringify({ model, max_tokens: 256, stream: streaming, messages: [{ role: "user", content: message }] });
+    const body = JSON.stringify({
+      model,
+      max_tokens: 256,
+      stream: true,
+      messages: [{ role: "user", content: message }],
+    });
 
     const headers: Record<string, string> = { "Content-Type": "application/json" };
-    if (isOpenAi) {
-      headers["Authorization"] = `Bearer ${authKey}`;
-    } else {
+    if (format === "anthropic") {
       headers["x-api-key"] = authKey;
       headers["anthropic-version"] = "2023-06-01";
+    } else {
+      // OpenAI-style: use Authorization Bearer
+      headers["Authorization"] = `Bearer ${authKey}`;
+      headers["anthropic-version"] = "2023-06-01";
     }
 
     try {
@@ -99,25 +103,18 @@ function ProxyTestForm({ authKey, baseUrl }: ProxyTestDialogProps) {
         return;
       }
 
-      if (!streaming) {
-        // Non-streaming: read full JSON and pretty-print
-        const text = await res.text();
-        try { setOutput(JSON.stringify(JSON.parse(text), null, 2)); } catch { setOutput(text); }
-        setElapsed(Date.now() - start);
-      } else {
-        // Streaming: read SSE chunks progressively
-        const reader = res.body?.getReader();
-        if (!reader) { setError("No response body"); setTesting(false); return; }
-        const decoder = new TextDecoder();
-        let raw = "";
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          raw += decoder.decode(value, { stream: true });
-          setOutput(raw);
-        }
-        setElapsed(Date.now() - start);
+      const reader = res.body?.getReader();
+      if (!reader) { setError("No response body"); setTesting(false); return; }
+
+      const decoder = new TextDecoder();
+      let raw = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        raw += decoder.decode(value, { stream: true });
+        setOutput(raw);
       }
+      setElapsed(Date.now() - start);
     } catch (e) {
       setError((e as Error).message);
     } finally {
@@ -165,26 +162,6 @@ function ProxyTestForm({ authKey, baseUrl }: ProxyTestDialogProps) {
         </select>
       </div>
 
-      {/* Streaming toggle */}
-      <div className="flex items-center justify-between">
-        <Label className="text-[11px]">Streaming</Label>
-        <div className="flex gap-1">
-          {([true, false] as const).map((s) => (
-            <button
-              key={String(s)}
-              onClick={() => setStreaming(s)}
-              className={`h-7 px-3 rounded-md text-[11px] font-medium border transition-colors cursor-pointer ${
-                streaming === s
-                  ? "bg-primary text-primary-foreground border-primary"
-                  : "bg-muted text-muted-foreground border-transparent hover:bg-muted/80"
-              }`}
-            >
-              {s ? "Stream" : "JSON"}
-            </button>
-          ))}
-        </div>
-      </div>
-
       {/* Message + Test button */}
       <div className="space-y-1.5">
         <Label className="text-[11px]">Message</Label>

package/src/web/lib/api-settings.ts

@@ -191,10 +191,8 @@ export interface ProxySettings {
   authKey: string | null;
   requestCount: number;
   localEndpoint: string;
-  localOpenAiEndpoint: string;
   tunnelUrl: string | null;
   proxyEndpoint: string | null;
-  openAiEndpoint: string | null;
 }
 
 export function getProxySettings(): Promise<ProxySettings> {