@bytetrue/byspace 0.1.0

package/node_modules/@bytetrue/byspace-server/dist/server/server/utils/diff-highlighter.js

@@ -0,0 +1,279 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { highlightCode, isLanguageSupported, } from "@bytetrue/byspace-highlight";
+/**
+ * Parse a unified diff into structured data
+ */
+// Git's default patch headers use paired a/path and b/path prefixes, while
+// diff.noprefix emits plain paths that may legitimately start with a/ or b/.
+function usesDiffPathPrefixes(oldPath, newPath) {
+    return oldPath.startsWith("a/") && newPath.startsWith("b/");
+}
+function extractPathFromMetadata(lines, prefix) {
+    const line = lines.find((candidate) => candidate.startsWith(prefix));
+    if (!line) {
+        return null;
+    }
+    const path = line.slice(prefix.length).replace(/\t.*$/, "").trimEnd();
+    return path === "/dev/null" ? null : path;
+}
+function extractPathFromDiffHeader(lines) {
+    const firstLine = lines[0] ?? "";
+    const prefixedPathMatch = firstLine.match(/^a\/(.+) b\/(.+)$/);
+    if (prefixedPathMatch) {
+        return prefixedPathMatch[2];
+    }
+    const metadataPath = extractPathFromMetadata(lines, "+++ ") ?? extractPathFromMetadata(lines, "--- ");
+    if (metadataPath) {
+        return metadataPath;
+    }
+    const pathMatch = firstLine.match(/^(\S+)\s+(\S+)$/);
+    if (pathMatch) {
+        const [, oldPath, newPath] = pathMatch;
+        const path = newPath === "/dev/null" ? oldPath : newPath;
+        return usesDiffPathPrefixes(oldPath, newPath) ? path.slice(2) : path;
+    }
+    return "unknown";
+}
+function isMetadataLine(line) {
+    return (line.startsWith("index ") ||
+        line.startsWith("--- ") ||
+        line.startsWith("+++ ") ||
+        line.startsWith("new file mode") ||
+        line.startsWith("deleted file mode"));
+}
+function parseHunkHeader(line) {
+    const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    if (!hunkMatch)
+        return null;
+    return {
+        oldStart: parseInt(hunkMatch[1], 10),
+        oldCount: parseInt(hunkMatch[2] ?? "1", 10),
+        newStart: parseInt(hunkMatch[3], 10),
+        newCount: parseInt(hunkMatch[4] ?? "1", 10),
+        lines: [{ type: "header", content: line.match(/^(@@ .+? @@)/)?.[1] ?? line }],
+    };
+}
+function parseSectionBody(lines) {
+    const hunks = [];
+    let currentHunk = null;
+    let additions = 0;
+    let deletions = 0;
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (isMetadataLine(line))
+            continue;
+        const newHunk = parseHunkHeader(line);
+        if (newHunk) {
+            if (currentHunk)
+                hunks.push(currentHunk);
+            currentHunk = newHunk;
+            continue;
+        }
+        if (!currentHunk)
+            continue;
+        if (line.startsWith("+")) {
+            currentHunk.lines.push({ type: "add", content: line.slice(1) });
+            additions++;
+        }
+        else if (line.startsWith("-")) {
+            currentHunk.lines.push({ type: "remove", content: line.slice(1) });
+            deletions++;
+        }
+        else if (line.startsWith(" ")) {
+            currentHunk.lines.push({ type: "context", content: line.slice(1) });
+        }
+        else if (line.length > 0 && !line.startsWith("\\")) {
+            currentHunk.lines.push({ type: "context", content: line });
+        }
+    }
+    if (currentHunk)
+        hunks.push(currentHunk);
+    return { hunks, additions, deletions };
+}
+export function parseDiff(diffText) {
+    if (!diffText || diffText.trim().length === 0) {
+        return [];
+    }
+    const files = [];
+    const fileSections = diffText.split(/^diff --git /m).filter(Boolean);
+    for (const section of fileSections) {
+        const lines = section.split("\n");
+        const isNew = section.includes("new file mode") || section.includes("--- /dev/null");
+        const isDeleted = section.includes("deleted file mode") || section.includes("+++ /dev/null");
+        const path = extractPathFromDiffHeader(lines);
+        const { hunks, additions, deletions } = parseSectionBody(lines);
+        files.push({ path, isNew, isDeleted, additions, deletions, hunks });
+    }
+    return files;
+}
+/**
+ * Reconstruct the "new" version of a file from diff hunks.
+ * Returns a map of new line numbers to their content.
+ */
+export function reconstructNewFile(hunks) {
+    const lines = new Map();
+    for (const hunk of hunks) {
+        let newLineNum = hunk.newStart;
+        for (const line of hunk.lines) {
+            if (line.type === "header")
+                continue;
+            if (line.type === "add" || line.type === "context") {
+                lines.set(newLineNum, line.content);
+                newLineNum++;
+            }
+        }
+    }
+    return lines;
+}
+/**
+ * Reconstruct the "old" version of a file from diff hunks.
+ * Returns a map of old line numbers to their content.
+ */
+export function reconstructOldFile(hunks) {
+    const lines = new Map();
+    for (const hunk of hunks) {
+        let oldLineNum = hunk.oldStart;
+        for (const line of hunk.lines) {
+            if (line.type === "header")
+                continue;
+            if (line.type === "remove" || line.type === "context") {
+                lines.set(oldLineNum, line.content);
+                oldLineNum++;
+            }
+        }
+    }
+    return lines;
+}
+function buildFileContent(lineMap) {
+    if (lineMap.size === 0)
+        return "";
+    const lineNumbers = Array.from(lineMap.keys()).sort((a, b) => a - b);
+    const minLine = lineNumbers[0];
+    const maxLine = lineNumbers[lineNumbers.length - 1];
+    const lines = [];
+    for (let i = minLine; i <= maxLine; i++) {
+        lines.push(lineMap.get(i) ?? "");
+    }
+    return lines.join("\n");
+}
+function buildTokenLookup(lineMap, highlighted) {
+    const lookup = new Map();
+    if (lineMap.size === 0)
+        return lookup;
+    const lineNumbers = Array.from(lineMap.keys()).sort((a, b) => a - b);
+    const minLine = lineNumbers[0];
+    for (let i = 0; i < highlighted.length; i++) {
+        const lineNum = minLine + i;
+        if (lineMap.has(lineNum)) {
+            lookup.set(lineNum, highlighted[i]);
+        }
+    }
+    return lookup;
+}
+function buildFullFileTokenLookup(fileContent, path) {
+    const lookup = new Map();
+    const highlighted = highlightCode(fileContent, path);
+    for (let i = 0; i < highlighted.length; i++) {
+        lookup.set(i + 1, highlighted[i]);
+    }
+    return lookup;
+}
+function buildReconstructedTokenLookups(file) {
+    const newFileLines = reconstructNewFile(file.hunks);
+    const oldFileLines = reconstructOldFile(file.hunks);
+    const newFileContent = buildFileContent(newFileLines);
+    const oldFileContent = buildFileContent(oldFileLines);
+    const newHighlighted = highlightCode(newFileContent, file.path);
+    const oldHighlighted = highlightCode(oldFileContent, file.path);
+    return {
+        newTokensByLine: buildTokenLookup(newFileLines, newHighlighted),
+        oldTokensByLine: buildTokenLookup(oldFileLines, oldHighlighted),
+    };
+}
+/**
+ * Apply syntax highlighting to diff hunks using reconstructed file content.
+ * This is the fallback when actual file content is not available.
+ */
+export function highlightDiffFromHunks(file) {
+    if (!isLanguageSupported(file.path)) {
+        return file;
+    }
+    const { newTokensByLine, oldTokensByLine } = buildReconstructedTokenLookups(file);
+    return applyTokensToHunks(file, newTokensByLine, oldTokensByLine);
+}
+/**
+ * Apply syntax highlighting to diff hunks using actual file content.
+ * This provides better context for the parser.
+ */
+export async function highlightDiffWithFileContent(file, cwd, options = {}) {
+    if (!isLanguageSupported(file.path)) {
+        return file;
+    }
+    const reconstructedTokens = buildReconstructedTokenLookups(file);
+    let newTokensByLine = reconstructedTokens.newTokensByLine;
+    let oldTokensByLine = reconstructedTokens.oldTokensByLine;
+    if (typeof options.oldFileContent === "string") {
+        oldTokensByLine = buildFullFileTokenLookup(options.oldFileContent, file.path);
+    }
+    if (typeof options.newFileContent === "string") {
+        newTokensByLine = buildFullFileTokenLookup(options.newFileContent, file.path);
+        return applyTokensToHunks(file, newTokensByLine, oldTokensByLine);
+    }
+    const filePath = resolve(cwd, file.path);
+    try {
+        const fileContent = await readFile(filePath, "utf-8");
+        newTokensByLine = buildFullFileTokenLookup(fileContent, file.path);
+    }
+    catch {
+        // If file read fails (deleted file, etc.), fall back to reconstructed new-side tokens.
+    }
+    return applyTokensToHunks(file, newTokensByLine, oldTokensByLine);
+}
+function applyTokensToHunks(file, newTokensByLine, oldTokensByLine) {
+    const highlightedHunks = file.hunks.map((hunk) => {
+        let oldLineNum = hunk.oldStart;
+        let newLineNum = hunk.newStart;
+        const highlightedLines = hunk.lines.map((line) => {
+            if (line.type === "header") {
+                return line;
+            }
+            let tokens;
+            if (line.type === "add") {
+                tokens = newTokensByLine.get(newLineNum);
+                newLineNum++;
+            }
+            else if (line.type === "remove") {
+                tokens = oldTokensByLine.get(oldLineNum);
+                oldLineNum++;
+            }
+            else if (line.type === "context") {
+                // Context lines exist in both - use new file version
+                tokens = newTokensByLine.get(newLineNum);
+                oldLineNum++;
+                newLineNum++;
+            }
+            return tokens ? { ...line, tokens } : line;
+        });
+        return { ...hunk, lines: highlightedLines };
+    });
+    return { ...file, hunks: highlightedHunks };
+}
+/**
+ * Parse and highlight a complete diff, using actual file content when available.
+ */
+export async function parseAndHighlightDiff(diffText, cwd, options = {}) {
+    const files = parseDiff(diffText);
+    const highlightedFiles = await Promise.all(files.map(async (file) => {
+        const [oldFileContent, newFileContent] = await Promise.all([
+            options.getOldFileContent?.(file),
+            options.getNewFileContent?.(file),
+        ]);
+        return highlightDiffWithFileContent(file, cwd, {
+            oldFileContent: oldFileContent ?? undefined,
+            newFileContent: newFileContent ?? undefined,
+        });
+    }));
+    return highlightedFiles;
+}
+//# sourceMappingURL=diff-highlighter.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/voice-config.d.ts

@@ -0,0 +1,15 @@
+export declare function stripVoiceModeSystemPrompt(existing?: string): string | undefined;
+export declare function buildVoiceModeSystemPrompt(existing: string | undefined, enabled: boolean): string;
+export declare function wrapSpokenInput(text: string): string;
+export declare function buildVoiceAgentMcpServerConfig(params: {
+    command: string;
+    baseArgs: string[];
+    socketPath: string;
+    env?: Record<string, string>;
+}): {
+    type: "stdio";
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+};
+//# sourceMappingURL=voice-config.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/voice-config.js

@@ -0,0 +1,54 @@
+const VOICE_PROMPT_BLOCK_START = "<byspace_voice_mode>";
+const VOICE_PROMPT_BLOCK_END = "</byspace_voice_mode>";
+const VOICE_AGENT_SYSTEM_INSTRUCTION = [
+    "BySpace voice mode is now on.",
+    "You are the BySpace voice assistant.",
+    "The user cannot see your chat messages or tool calls.",
+    "Always use the speak tool for all user-facing communication.",
+    "Before calling any non-speak tool, first call speak with a short acknowledgement of what you heard and what you will do next.",
+    "For long-running work, use speak to provide progress updates before and during execution.",
+    "Treat the user input as transcribed speech.",
+    "If the user intent is clear, proceed without extra confirmation.",
+    "If the transcription seems incomplete, cut off, ambiguous, or may contain a non-obvious mistake or misspelling, ask a clarifying question via speak before taking action.",
+    "Use concise plain language suitable for speech output.",
+].join(" ");
+const VOICE_AGENT_DISABLED_INSTRUCTION = [
+    "BySpace voice mode is now off.",
+    "Ignore any earlier BySpace voice mode instructions in this thread.",
+].join(" ");
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function makeVoicePromptBlockRegex() {
+    return new RegExp(`${escapeRegExp(VOICE_PROMPT_BLOCK_START)}[\\s\\S]*?${escapeRegExp(VOICE_PROMPT_BLOCK_END)}`, "g");
+}
+export function stripVoiceModeSystemPrompt(existing) {
+    const trimmed = existing?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const stripped = trimmed.replace(makeVoicePromptBlockRegex(), "").trim();
+    return stripped.length > 0 ? stripped : undefined;
+}
+export function buildVoiceModeSystemPrompt(existing, enabled) {
+    const basePrompt = stripVoiceModeSystemPrompt(existing);
+    const voiceInstruction = enabled
+        ? VOICE_AGENT_SYSTEM_INSTRUCTION
+        : VOICE_AGENT_DISABLED_INSTRUCTION;
+    const voiceBlock = [VOICE_PROMPT_BLOCK_START, voiceInstruction, VOICE_PROMPT_BLOCK_END].join("\n");
+    return [basePrompt, voiceBlock]
+        .filter((entry) => typeof entry === "string" && entry.length > 0)
+        .join("\n\n");
+}
+export function wrapSpokenInput(text) {
+    return `<spoken-input>\n${text}\n</spoken-input>\n<instruction>This message was spoken by the user. Respond using the speak tool only, not normal messages, because the user may not be looking at the chat.</instruction>`;
+}
+export function buildVoiceAgentMcpServerConfig(params) {
+    return {
+        type: "stdio",
+        command: params.command,
+        args: [...params.baseArgs, "--socket", params.socketPath],
+        ...(params.env ? { env: params.env } : {}),
+    };
+}
+//# sourceMappingURL=voice-config.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/voice-permission-policy.d.ts

@@ -0,0 +1,4 @@
+import type { AgentPermissionRequest } from "./agent/agent-sdk-types.js";
+/** Voice assistant policy: only allow the speak tool. */
+export declare function isVoicePermissionAllowed(request: AgentPermissionRequest): boolean;
+//# sourceMappingURL=voice-permission-policy.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/voice-permission-policy.js

@@ -0,0 +1,13 @@
+import { isSpeakToolName } from "@bytetrue/byspace-protocol/tool-name-normalization";
+/** Voice assistant policy: only allow the speak tool. */
+export function isVoicePermissionAllowed(request) {
+    if (request.kind !== "tool") {
+        return false;
+    }
+    const normalizedName = request.name.trim().toLowerCase();
+    if (!normalizedName) {
+        return false;
+    }
+    return isSpeakToolName(normalizedName);
+}
+//# sourceMappingURL=voice-permission-policy.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/voice-types.d.ts

@@ -0,0 +1,12 @@
+export type VoiceSpeakHandler = (params: {
+    text: string;
+    callerAgentId: string;
+    signal?: AbortSignal;
+}) => Promise<void>;
+export interface VoiceCallerContext {
+    childAgentDefaultLabels?: Record<string, string>;
+    lockedCwd?: string;
+    allowCustomCwd?: boolean;
+    enableVoiceTools?: boolean;
+}
+//# sourceMappingURL=voice-types.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/voice-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=voice-types.js.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/web-ui.d.ts

@@ -0,0 +1,10 @@
+import type { RequestHandler } from "express";
+import type { Logger } from "pino";
+export interface WebUiMiddlewareOptions {
+    enabled: boolean;
+    distDir: string | null;
+    label: string;
+    logger: Logger;
+}
+export declare function createWebUiMiddleware(options: WebUiMiddlewareOptions): RequestHandler;
+//# sourceMappingURL=web-ui.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/web-ui.js

@@ -0,0 +1,205 @@
+import { createReadStream, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+const EXCLUDED_PATH_PREFIXES = ["/api/", "/mcp/", "/public/"];
+const EXCLUDED_PATHS = new Set(["/api", "/mcp", "/public"]);
+function isExcludedPath(requestPath) {
+    for (const prefix of EXCLUDED_PATH_PREFIXES) {
+        if (requestPath.startsWith(prefix)) {
+            return true;
+        }
+    }
+    return EXCLUDED_PATHS.has(requestPath);
+}
+const CONTENT_TYPES = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "application/javascript; charset=utf-8",
+    ".mjs": "application/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf",
+    ".otf": "font/otf",
+    ".eot": "application/vnd.ms-fontobject",
+    ".map": "application/json",
+};
+function getContentType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return CONTENT_TYPES[ext] ?? "application/octet-stream";
+}
+function selectEncoding(acceptEncoding) {
+    if (!acceptEncoding) {
+        return null;
+    }
+    const normalized = acceptEncoding.toLowerCase();
+    if (normalized.includes("br")) {
+        return "br";
+    }
+    if (normalized.includes("gzip")) {
+        return "gzip";
+    }
+    return null;
+}
+function isHashedAsset(filePath) {
+    const base = path.basename(filePath);
+    // Match content hashes like index-abc123def456.js or main.abc123def456.css.
+    return /[-.][0-9a-f]{16,}[-.]/i.test(base);
+}
+function isInsideDir(targetPath, dirPath) {
+    const resolvedDir = path.resolve(dirPath);
+    const resolvedTarget = path.resolve(targetPath);
+    return resolvedTarget === resolvedDir || resolvedTarget.startsWith(resolvedDir + path.sep);
+}
+function resolveTargetFile(distDir, requestPath) {
+    const safePath = path.normalize(requestPath).replace(/^(\.\.[/\\])+/, "");
+    let filePath = path.join(distDir, safePath);
+    const stat = safeStat(filePath);
+    if (stat?.isDirectory()) {
+        filePath = path.join(filePath, "index.html");
+    }
+    const finalStat = safeStat(filePath);
+    if (!finalStat?.isFile()) {
+        filePath = path.join(distDir, "index.html");
+        const fallbackStat = safeStat(filePath);
+        if (!fallbackStat?.isFile()) {
+            return null;
+        }
+    }
+    if (!isInsideDir(filePath, distDir)) {
+        return null;
+    }
+    const resolvedFile = path.resolve(filePath);
+    const isIndexHtml = path.basename(resolvedFile).toLowerCase() === "index.html";
+    return { resolvedFile, isIndexHtml };
+}
+function safeStat(filePath) {
+    try {
+        return statSync(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveContentEncoding(resolvedFile, acceptEncoding) {
+    const encoding = selectEncoding(acceptEncoding);
+    if (!encoding) {
+        return { finalFile: resolvedFile, contentEncoding: null };
+    }
+    const compressedFile = `${resolvedFile}.${encoding === "br" ? "br" : "gz"}`;
+    const compressedStat = safeStat(compressedFile);
+    if (compressedStat?.isFile()) {
+        return { finalFile: compressedFile, contentEncoding: encoding };
+    }
+    return { finalFile: resolvedFile, contentEncoding: null };
+}
+function setResponseCacheHeaders(res, isIndexHtml, resolvedFile) {
+    if (isIndexHtml) {
+        res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate");
+        res.setHeader("Pragma", "no-cache");
+        res.setHeader("Expires", "0");
+    }
+    else if (isHashedAsset(resolvedFile)) {
+        res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+    }
+    else {
+        res.setHeader("Cache-Control", "no-cache");
+    }
+}
+export function createWebUiMiddleware(options) {
+    const { enabled, distDir, label, logger } = options;
+    const childLogger = logger.child({ module: "web-ui" });
+    if (!enabled || !distDir) {
+        childLogger.info({ enabled, hasDistDir: !!distDir }, "Daemon web UI disabled or missing dist directory");
+    }
+    else {
+        childLogger.info({ distDir }, "Daemon web UI mounted");
+    }
+    return (req, res, next) => {
+        if (req.method !== "GET" && req.method !== "HEAD") {
+            next();
+            return;
+        }
+        if (isExcludedPath(req.path)) {
+            next();
+            return;
+        }
+        if (!enabled || !distDir) {
+            res.status(404).end();
+            return;
+        }
+        serveWebUiFile({ distDir, requestPath: req.path, label, req, res });
+    };
+}
+function serveWebUiFile(options) {
+    const { distDir, requestPath, label, req, res } = options;
+    const target = resolveTargetFile(distDir, requestPath);
+    if (!target) {
+        res.status(404).end();
+        return;
+    }
+    const { resolvedFile, isIndexHtml } = target;
+    const acceptEncoding = isIndexHtml ? undefined : req.headers["accept-encoding"];
+    const { finalFile, contentEncoding } = resolveContentEncoding(resolvedFile, acceptEncoding);
+    res.setHeader("Content-Type", getContentType(resolvedFile));
+    if (contentEncoding) {
+        res.setHeader("Content-Encoding", contentEncoding);
+        res.setHeader("Vary", "Accept-Encoding");
+    }
+    setResponseCacheHeaders(res, isIndexHtml, resolvedFile);
+    if (req.method === "HEAD") {
+        res.status(200).end();
+        return;
+    }
+    if (isIndexHtml) {
+        sendIndexHtml(res, finalFile, req, label);
+        return;
+    }
+    const stream = createReadStream(finalFile);
+    stream.on("error", () => {
+        if (!res.headersSent) {
+            res.status(500).end();
+        }
+        else {
+            res.end();
+        }
+    });
+    stream.pipe(res);
+}
+function sendIndexHtml(res, filePath, req, label) {
+    try {
+        const html = readFileSync(filePath, "utf-8");
+        const injected = injectConnectionHint(html, req, label);
+        res.status(200).send(injected);
+    }
+    catch {
+        res.status(500).end();
+    }
+}
+function serializeInlineScriptJson(value) {
+    return JSON.stringify(value)
+        .replace(/</g, "\\u003C")
+        .replace(/>/g, "\\u003E")
+        .replace(/&/g, "\\u0026");
+}
+function injectConnectionHint(html, req, label) {
+    const host = typeof req.headers.host === "string" ? req.headers.host : "";
+    const useTls = req.protocol === "https";
+    const hint = {
+        listen: host,
+        useTls,
+        label,
+    };
+    const script = `<script>window.__BYSPACE_INITIAL_DAEMON_CONNECTION__=${serializeInlineScriptJson(hint)}</script>`;
+    const headClose = /<\/head>/i;
+    if (headClose.test(html)) {
+        return html.replace(headClose, `${script}</head>`);
+    }
+    return script + html;
+}
+//# sourceMappingURL=web-ui.js.map