mixdog 0.9.69 → 0.9.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.69",
+  "version": "0.9.70",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -85,6 +85,8 @@
     "test:session": "node --test scripts/session-orphan-sweep-test.mjs scripts/interrupted-turn-history-test.mjs scripts/session-heartbeat-lifecycle-test.mjs scripts/remote-transition-order-test.mjs",
     "test:rebindtail": "node --test scripts/forwarder-rebind-tail-test.mjs",
     "test:workflow-editor": "node --test scripts/workflow-id-test.mjs scripts/workflow-pack-editor-test.mjs",
+    "test:route-scope": "node --test scripts/route-scope-isolation-test.mjs",
+    "test:schedule-reload": "node --test scripts/schedule-reload-arm-test.mjs",
     "failures": "node scripts/tool-failures.mjs",
     "trace:llm": "node scripts/llm-trace-summary.mjs",
     "diag:sessions": "node scripts/session-diag.mjs",

package/src/runtime/channels/lib/owned-runtime.mjs

@@ -477,7 +477,14 @@ async function reloadRuntimeConfig() {
     getConfig().interactive ?? [],
     // Single resolved main-channel id used for the schedule `channel` flag.
     getConfig().channelId,
-    { restart: getBridgeRuntimeConnected() }
+    // The scheduler must be RE-ARMED by the reload whenever it is supposed to
+    // be running. `restart: false` only destroys the cron/one-shot bindings and
+    // hands lifecycle back to the caller — but on an automation-only install
+    // (no messaging backend) startAutomationRuntime() is already past its
+    // `automationRunning` guard, so nobody would ever call scheduler.start()
+    // again and every saved/edited schedule stayed silently disarmed until the
+    // daemon restarted.
+    { restart: automationRunning || getBridgeRuntimeConnected() }
   );
   const nextBackend = createBackend(getConfig());
   const backendTypeChanged = (nextBackend?.name || "") !== previousBackendName;

package/src/runtime/media/adapters/codex-image.mjs

@@ -0,0 +1,109 @@
+/**
+ * ChatGPT OAuth image adapter (`openai-oauth` lane).
+ *
+ * Runs the hosted `image_generation` tool on the Codex responses backend — the
+ * same endpoint/headers the chat provider uses, so the subscription session is
+ * the only credential involved. The final image arrives as base64 on the
+ * image_generation_call item; partial frames are kept as a fallback.
+ */
+import { randomBytes } from 'crypto';
+import { resolveCodexAuth } from '../auth.mjs';
+import { mediaError } from '../lanes.mjs';
+import { upstreamError } from '../upstream-error.mjs';
+import { CODEX_OAUTH_ORIGINATOR, CODEX_RESPONSES_URL } from '../../agent/orchestrator/providers/openai-oauth.mjs';
+
+const REQUEST_TIMEOUT_MS = 400_000;
+
+function imageTool(options = {}) {
+  const tool = { type: 'image_generation' };
+  const size = String(options.size || 'auto');
+  if (size && size !== 'auto') tool.size = size;
+  const quality = String(options.quality || 'auto');
+  if (quality && quality !== 'auto') tool.quality = quality;
+  return tool;
+}
+
+function collectImage(event, state) {
+  const item = event?.item;
+  if (event?.type === 'response.output_item.done' && item?.type === 'image_generation_call') {
+    if (typeof item.result === 'string' && item.result.length > 0) state.final = item.result;
+    if (typeof item.revised_prompt === 'string') state.revisedPrompt = item.revised_prompt;
+    return;
+  }
+  if (event?.type === 'response.image_generation_call.partial_image') {
+    const partial = event?.partial_image_b64;
+    if (typeof partial === 'string' && partial.length > (state.partial?.length || 0)) state.partial = partial;
+  }
+}
+
+export async function generateImage({ model, prompt, options = {}, references = [], signal }) {
+  const auth = await resolveCodexAuth();
+  // Reference images ride as input_image parts on the user turn — the same
+  // shape the chat path uses for pasted images.
+  const content = [
+    ...references.map((ref) => ({
+      type: 'input_image',
+      image_url: `data:${ref.mime || 'image/png'};base64,${ref.base64}`,
+    })),
+    { type: 'input_text', text: prompt },
+  ];
+  const body = {
+    model,
+    stream: true,
+    store: false,
+    instructions: 'You generate images with the image_generation tool. Call the tool once for the user request; do not ask follow-up questions.',
+    input: [{ type: 'message', role: 'user', content }],
+    tools: [imageTool(options)],
+    tool_choice: 'auto',
+  };
+  const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
+  const res = await fetch(CODEX_RESPONSES_URL, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${auth.access_token}`,
+      'Content-Type': 'application/json',
+      Accept: 'text/event-stream',
+      'OpenAI-Beta': 'responses=experimental',
+      originator: CODEX_OAUTH_ORIGINATOR,
+      'chatgpt-account-id': auth.account_id || '',
+      'x-client-request-id': randomBytes(16).toString('hex'),
+    },
+    body: JSON.stringify(body),
+    signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+  });
+  if (!res.ok || !res.body) throw upstreamError('ChatGPT image', res.status, await res.text().catch(() => ''));
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  const state = { final: '', partial: '', revisedPrompt: null };
+  let buffer = '';
+  let failure = null;
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      for (const line of lines) {
+        if (!line.startsWith('data:')) continue;
+        const raw = line.slice(5).trim();
+        if (!raw || raw === '[DONE]') continue;
+        let event;
+        try { event = JSON.parse(raw); } catch { continue; }
+        if (event?.type === 'response.failed' || event?.type === 'error') {
+          failure = event?.response?.error?.message || event?.message || 'stream failed';
+        }
+        collectImage(event, state);
+      }
+    }
+  } finally {
+    try { reader.releaseLock(); } catch {}
+  }
+
+  const b64 = state.final || state.partial;
+  if (!b64) {
+    throw mediaError(`ChatGPT returned no image data${failure ? `: ${failure}` : ''}`, 'MEDIA_EMPTY_RESULT', 502);
+  }
+  return { bytes: Buffer.from(b64, 'base64'), mime: 'image/png', revisedPrompt: state.revisedPrompt };
+}

package/src/runtime/media/adapters/gemini-image.mjs

@@ -0,0 +1,68 @@
+/**
+ * Gemini image adapter (API key lane).
+ *
+ * Calls the Generative Language `generateContent` route and pulls the first
+ * inline image part out of the candidate. Aspect ratio rides in `imageConfig`,
+ * which older image models reject — a 400 there retries once without it so a
+ * control the model does not know never fails the whole generation.
+ */
+import { resolveGeminiKey } from '../auth.mjs';
+import { mediaError } from '../lanes.mjs';
+import { upstreamError } from '../upstream-error.mjs';
+
+const BASE_URL = 'https://generativelanguage.googleapis.com/v1beta/models';
+const REQUEST_TIMEOUT_MS = 180_000;
+
+function requestBody(prompt, options, withImageConfig, references = []) {
+  const body = {
+    contents: [{
+      role: 'user',
+      parts: [
+        ...references.map((ref) => ({
+          inlineData: { mimeType: ref.mime || 'image/png', data: ref.base64 },
+        })),
+        { text: prompt },
+      ],
+    }],
+  };
+  const aspect = String(options?.aspectRatio || 'auto');
+  if (withImageConfig && aspect !== 'auto') {
+    body.generationConfig = { imageConfig: { aspectRatio: aspect } };
+  }
+  return body;
+}
+
+async function post(model, key, body, signal) {
+  return await fetch(`${BASE_URL}/${encodeURIComponent(model)}:generateContent`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'x-goog-api-key': key },
+    body: JSON.stringify(body),
+    signal: AbortSignal.any([signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)].filter(Boolean)),
+  });
+}
+
+export async function generateImage({ model, prompt, options = {}, references = [], signal }) {
+  const key = resolveGeminiKey();
+  const wantsImageConfig = String(options.aspectRatio || 'auto') !== 'auto';
+  let res = await post(model, key, requestBody(prompt, options, wantsImageConfig, references), signal);
+  if (!res.ok && res.status === 400 && wantsImageConfig) {
+    res = await post(model, key, requestBody(prompt, options, false, references), signal);
+  }
+  if (!res.ok) throw upstreamError('Gemini image', res.status, await res.text().catch(() => ''));
+  const data = await res.json();
+  const parts = data?.candidates?.[0]?.content?.parts || [];
+  const image = parts.find((part) => part?.inlineData?.data);
+  if (!image) {
+    const refusal = parts.find((part) => typeof part?.text === 'string')?.text || '';
+    throw mediaError(
+      `Gemini returned no image data${refusal ? `: ${refusal.slice(0, 200)}` : ''}`,
+      'MEDIA_EMPTY_RESULT',
+      502,
+    );
+  }
+  return {
+    bytes: Buffer.from(image.inlineData.data, 'base64'),
+    mime: image.inlineData.mimeType || 'image/png',
+    revisedPrompt: null,
+  };
+}

package/src/runtime/media/adapters/gemini-video.mjs

@@ -0,0 +1,119 @@
+/**
+ * Gemini video adapter (API key lane).
+ *
+ * Two different upstream shapes live behind one lane:
+ *   - Omni Flash answers on the Interactions API in a single call, with the
+ *     mp4 inline as base64 on a `model_output` step.
+ *   - Veo 3.1 is a long-running predict: submit, poll the operation, then pull
+ *     the sample URI with `alt=media`.
+ */
+import { resolveGeminiKey } from '../auth.mjs';
+import { mediaError } from '../lanes.mjs';
+import { upstreamError } from '../upstream-error.mjs';
+
+const BASE_URL = 'https://generativelanguage.googleapis.com/v1beta';
+const OMNI_TIMEOUT_MS = 600_000;
+const POLL_INTERVAL_MS = 8_000;
+const TOTAL_TIMEOUT_MS = 900_000;
+
+export function isOmniModel(model) {
+  return /omni/i.test(String(model || ''));
+}
+
+function aspectFor(options) {
+  const aspect = String(options?.aspectRatio || 'auto');
+  return aspect === 'auto' ? '16:9' : aspect;
+}
+
+async function generateViaOmni({ model, prompt, options, references = [], signal, key }) {
+  // Omni takes a multimodal input array; a reference image switches the task
+  // from text-to-video to image-to-video.
+  const input = references.length
+    ? [
+      ...references.map((ref) => ({ type: 'image', data: ref.base64, mime_type: ref.mime || 'image/png' })),
+      { type: 'text', text: prompt },
+    ]
+    : prompt;
+  const res = await fetch(`${BASE_URL}/interactions`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'x-goog-api-key': key },
+    body: JSON.stringify({
+      model,
+      input,
+      response_format: { type: 'video', aspect_ratio: aspectFor(options) },
+      generation_config: {
+        video_config: { task: references.length ? 'image_to_video' : 'text_to_video' },
+      },
+    }),
+    signal: AbortSignal.any([signal, AbortSignal.timeout(OMNI_TIMEOUT_MS)].filter(Boolean)),
+  });
+  if (!res.ok) throw upstreamError('Gemini Omni video', res.status, await res.text().catch(() => ''));
+  const data = await res.json();
+  for (const step of data?.steps || []) {
+    const content = Array.isArray(step?.content) ? step.content : [step?.content].filter(Boolean);
+    const video = content.find((item) => item?.type === 'video' && typeof item?.data === 'string');
+    if (video) {
+      return { bytes: Buffer.from(video.data, 'base64'), mime: video.mime_type || 'video/mp4' };
+    }
+  }
+  throw mediaError('Gemini Omni returned no video data', 'MEDIA_EMPTY_RESULT', 502);
+}
+
+async function generateViaVeo({ model, prompt, options, references = [], signal, onProgress, key }) {
+  const headers = { 'Content-Type': 'application/json', 'x-goog-api-key': key };
+  const parameters = { aspectRatio: aspectFor(options) };
+  const instance = { prompt };
+  // Veo accepts a single seed image for image-to-video.
+  if (references[0]) {
+    instance.image = { bytesBase64Encoded: references[0].base64, mimeType: references[0].mime || 'image/png' };
+  }
+  const resolution = String(options?.resolution || '');
+  if (resolution === '720p' || resolution === '1080p') parameters.resolution = resolution;
+  // Veo takes discrete clip lengths; anything else is rejected upstream, so an
+  // out-of-contract value is dropped rather than forwarded.
+  const duration = Math.trunc(Number(options?.duration) || 0);
+  if ([4, 6, 8].includes(duration)) parameters.durationSeconds = duration;
+
+  const started = await fetch(`${BASE_URL}/models/${encodeURIComponent(model)}:predictLongRunning`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({ instances: [instance], parameters }),
+    signal,
+  });
+  if (!started.ok) throw upstreamError('Veo video', started.status, await started.text().catch(() => ''));
+  const operation = await started.json();
+  if (!operation?.name) throw mediaError('Veo returned no operation name', 'MEDIA_UPSTREAM_FAILED', 502);
+
+  const deadline = Date.now() + TOTAL_TIMEOUT_MS;
+  for (;;) {
+    if (signal?.aborted) throw mediaError('canceled', 'MEDIA_CANCELED', 499);
+    if (Date.now() > deadline) throw mediaError('Veo poll budget exceeded', 'MEDIA_TIMEOUT', 504);
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    const poll = await fetch(`${BASE_URL}/${operation.name}`, { headers, signal });
+    if (!poll.ok) throw upstreamError('Veo poll', poll.status, await poll.text().catch(() => ''));
+    const data = await poll.json();
+    if (!data?.done) {
+      // The operation exposes no percentage; keep the UI moving with a coarse
+      // heartbeat instead of a fake number.
+      if (typeof onProgress === 'function') onProgress(50);
+      continue;
+    }
+    if (data.error) {
+      throw mediaError(`Veo generation failed: ${data.error.message || 'unknown error'}`, 'MEDIA_UPSTREAM_FAILED', 502);
+    }
+    const sample = data?.response?.generateVideoResponse?.generatedSamples?.[0]
+      || data?.response?.generatedVideos?.[0];
+    const uri = sample?.video?.uri || sample?.video?.fileUri;
+    if (!uri) throw mediaError('Veo finished without a video URI', 'MEDIA_EMPTY_RESULT', 502);
+    const file = await fetch(`${uri}${uri.includes('?') ? '&' : '?'}alt=media`, { headers, signal });
+    if (!file.ok) throw upstreamError('Veo download', file.status, await file.text().catch(() => ''));
+    return { bytes: Buffer.from(await file.arrayBuffer()), mime: 'video/mp4' };
+  }
+}
+
+export async function generateVideo({ model, prompt, options = {}, references = [], signal, onProgress }) {
+  const key = resolveGeminiKey();
+  return isOmniModel(model)
+    ? await generateViaOmni({ model, prompt, options, references, signal, key })
+    : await generateViaVeo({ model, prompt, options, references, signal, onProgress, key });
+}

package/src/runtime/media/adapters/xai-media.mjs

@@ -0,0 +1,116 @@
+/**
+ * xAI Imagine adapter (images + video) for the `grok-oauth` and `xai` lanes.
+ *
+ * Both lanes speak the same api.x.ai contract; only the bearer differs. Video
+ * is a submit + poll job: POST /videos/generations returns a request id and the
+ * poll route answers 202 while pending, 200 with a signed URL when done.
+ */
+import { resolveXaiAuth } from '../auth.mjs';
+import { mediaError } from '../lanes.mjs';
+import { upstreamError } from '../upstream-error.mjs';
+
+const POLL_INTERVAL_MS = 4_000;
+const START_TIMEOUT_MS = 60_000;
+const TOTAL_TIMEOUT_MS = 900_000;
+
+async function readError(res) {
+  const text = await res.text().catch(() => '');
+  return text.slice(0, 400);
+}
+
+function sizeParams({ aspectRatio, resolution }) {
+  const params = {};
+  const aspect = String(aspectRatio || 'auto');
+  if (aspect && aspect !== 'auto') params.aspect_ratio = aspect;
+  const res = String(resolution || '').toLowerCase();
+  if (res === '1k' || res === '2k') params.resolution = res;
+  return params;
+}
+
+/** Reference images ride as data URLs — xAI accepts them in place of a host. */
+function referenceUrl(reference) {
+  const data = String(reference?.base64 || '');
+  if (data.startsWith('data:')) return data;
+  return `data:${reference?.mime || 'image/png'};base64,${data}`;
+}
+
+export async function generateImage({ lane, model, prompt, options = {}, references = [], signal }) {
+  const { baseURL, token } = await resolveXaiAuth(lane);
+  const refs = references.map(referenceUrl).map((url) => ({ type: 'image_url', url }));
+  const body = {
+    model,
+    prompt,
+    n: 1,
+    response_format: 'b64_json',
+    // One reference edits that image; several composite into a new one.
+    ...(refs.length === 1 ? { image: refs[0] } : refs.length > 1 ? { images: refs } : {}),
+    ...sizeParams(options),
+  };
+  const route = refs.length ? 'images/edits' : 'images/generations';
+  const res = await fetch(`${baseURL}/${route}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
+    body: JSON.stringify(body),
+    signal,
+  });
+  if (!res.ok) throw upstreamError('xAI image', res.status, await readError(res));
+  const data = await res.json();
+  const entry = data?.data?.[0];
+  if (!entry?.b64_json) throw mediaError('xAI returned no image data', 'MEDIA_EMPTY_RESULT', 502);
+  return {
+    bytes: Buffer.from(entry.b64_json, 'base64'),
+    mime: entry.mime_type || 'image/png',
+    revisedPrompt: entry.revised_prompt || null,
+  };
+}
+
+export async function generateVideo({ lane, model, prompt, options = {}, references = [], signal, onProgress }) {
+  const { baseURL, token } = await resolveXaiAuth(lane);
+  const headers = { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` };
+  const duration = Math.min(15, Math.max(1, Math.trunc(Number(options.duration) || 5)));
+  const resolution = ['480p', '720p', '1080p'].includes(options.resolution) ? options.resolution : '480p';
+  const body = { model, prompt, duration, resolution };
+  const aspect = String(options.aspectRatio || 'auto');
+  if (aspect && aspect !== 'auto') body.aspect_ratio = aspect;
+  // Mode is inferred from the reference count: 1 = image-to-video,
+  // 2+ = reference-to-video (capped at the documented 7).
+  const refs = references.slice(0, 7).map(referenceUrl);
+  if (refs.length === 1) body.image = { url: refs[0] };
+  else if (refs.length > 1) body.reference_images = refs.map((url) => ({ url }));
+
+  const started = await fetch(`${baseURL}/videos/generations`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(body),
+    signal: AbortSignal.any([signal, AbortSignal.timeout(START_TIMEOUT_MS)].filter(Boolean)),
+  });
+  if (!started.ok) throw upstreamError('xAI video', started.status, await readError(started));
+  const startData = await started.json();
+  const requestId = startData?.request_id || startData?.id;
+  if (!requestId) throw mediaError('xAI video start returned no request id', 'MEDIA_UPSTREAM_FAILED', 502);
+
+  const deadline = Date.now() + TOTAL_TIMEOUT_MS;
+  for (;;) {
+    if (signal?.aborted) throw mediaError('canceled', 'MEDIA_CANCELED', 499);
+    if (Date.now() > deadline) throw mediaError('xAI video poll budget exceeded', 'MEDIA_TIMEOUT', 504);
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    const poll = await fetch(`${baseURL}/videos/${requestId}`, { headers, signal });
+    if (!poll.ok && poll.status !== 202) throw upstreamError('xAI video poll', poll.status, await readError(poll));
+    const data = await poll.json().catch(() => ({}));
+    if (typeof data?.progress === 'number' && typeof onProgress === 'function') onProgress(data.progress);
+    if (data?.status === 'done') {
+      const url = data?.video?.url;
+      if (!url) throw mediaError('xAI video finished without a URL', 'MEDIA_EMPTY_RESULT', 502);
+      const file = await fetch(url, { signal });
+      if (!file.ok) throw mediaError(`xAI video download failed (${file.status})`, 'MEDIA_UPSTREAM_FAILED', file.status);
+      return {
+        bytes: Buffer.from(await file.arrayBuffer()),
+        mime: 'video/mp4',
+        durationSeconds: Number(data?.video?.duration) || duration,
+      };
+    }
+    if (data?.status === 'failed' || data?.status === 'expired') {
+      throw mediaError(`xAI video ${data.status}${data?.error?.code ? `: ${data.error.code}` : ''}`, 'MEDIA_UPSTREAM_FAILED', 502);
+    }
+  }
+}

package/src/runtime/media/auth.mjs

@@ -0,0 +1,51 @@
+/**
+ * Credential resolution for media lanes.
+ *
+ * OAuth lanes reuse the chat providers' token stores (including their refresh
+ * paths) so the Studio never holds a second copy of a session. API-key lanes
+ * read the same keychain-backed store the agent providers use.
+ */
+import { getAgentApiKey } from '../shared/provider-api-key.mjs';
+
+export { hasGrokOAuthCredentials } from '../agent/orchestrator/providers/oauth-credential-probes.mjs';
+
+const XAI_BASE_URL = 'https://api.x.ai/v1';
+
+/**
+ * Bearer for the xAI media endpoints. `grok-oauth` refreshes through the chat
+ * provider; `xai` uses the stored API key. Both hit the same api.x.ai routes.
+ */
+export async function resolveXaiAuth(laneId) {
+  if (laneId === 'xai') {
+    const key = getAgentApiKey('xai');
+    if (!key) {
+      const err = new Error('xAI API key is not configured');
+      err.code = 'MEDIA_LANE_UNAUTHENTICATED';
+      err.status = 401;
+      throw err;
+    }
+    return { baseURL: XAI_BASE_URL, token: key };
+  }
+  const { GrokOAuthProvider } = await import('../agent/orchestrator/providers/grok-oauth.mjs');
+  const provider = new GrokOAuthProvider({});
+  const tokens = await provider.ensureAuth();
+  return { baseURL: XAI_BASE_URL, token: tokens.access_token };
+}
+
+/** Codex (ChatGPT OAuth) auth record: access token + account id for headers. */
+export async function resolveCodexAuth() {
+  const { OpenAIOAuthProvider } = await import('../agent/orchestrator/providers/openai-oauth.mjs');
+  const provider = new OpenAIOAuthProvider({});
+  return await provider.ensureAuth();
+}
+
+export function resolveGeminiKey() {
+  const key = getAgentApiKey('gemini');
+  if (!key) {
+    const err = new Error('Gemini API key is not configured');
+    err.code = 'MEDIA_LANE_UNAUTHENTICATED';
+    err.status = 401;
+    throw err;
+  }
+  return key;
+}

package/src/runtime/media/index.mjs

@@ -0,0 +1,17 @@
+/**
+ * Media studio surface (image / video generation).
+ *
+ * Single entry point for the session runtime: lane catalog, job control, and
+ * the on-disk asset store. Adapters are imported lazily by the job runner so a
+ * boot that never generates never pays for them.
+ */
+export { MEDIA_KINDS, listMediaLanes, getMediaLane } from './lanes.mjs';
+export { startMediaJob, getMediaJob, listMediaJobs, cancelMediaJob } from './jobs.mjs';
+export {
+  listMediaAssets,
+  readMediaAsset,
+  deleteMediaAsset,
+  mediaAssetPath,
+  openMediaAsset,
+  openMediaFolder,
+} from './store.mjs';