codepiper 0.1.0

package/packages/cli/src/commands/send.ts

@@ -0,0 +1,184 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { readErrorJson, readJson, responseErrorMessage } from "../lib/api";
+import { getRequiredValue } from "../lib/args";
+
+export interface SendOptions {
+  sessionId: string;
+  text: string;
+  socket: string;
+  newline: boolean;
+  image?: string;
+}
+
+const MAX_IMAGE_SIZE = 10 * 1024 * 1024; // 10MB
+
+export function parseSendOptions(args: string[]): SendOptions {
+  let sessionId: string | undefined;
+  let socket = "/tmp/codepiper.sock";
+  let newline = true;
+  let image: string | undefined;
+  const textParts: string[] = [];
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === undefined) {
+      continue;
+    }
+
+    if (arg === "--socket" || arg === "-s") {
+      socket = getRequiredValue(args, i, arg);
+      i++;
+    } else if (arg === "--newline" || arg === "-n") {
+      newline = true;
+    } else if (arg === "--no-newline") {
+      newline = false;
+    } else if (arg === "--image" || arg === "-i") {
+      image = getRequiredValue(args, i, arg);
+      i++;
+    } else if (!arg.startsWith("-")) {
+      if (!sessionId) {
+        sessionId = arg;
+      } else {
+        textParts.push(arg);
+      }
+    }
+  }
+
+  if (!sessionId) {
+    throw new Error("session-id is required");
+  }
+
+  const text = textParts.join(" ");
+  if (!(text || image)) {
+    throw new Error("text or --image is required");
+  }
+
+  const options: SendOptions = {
+    sessionId,
+    text,
+    socket,
+    newline,
+  };
+  if (image !== undefined) {
+    options.image = image;
+  }
+
+  return options;
+}
+
+export async function uploadImage(
+  sessionId: string,
+  filePath: string,
+  socket: string
+): Promise<string> {
+  const resolved = path.resolve(filePath);
+  const stat = fs.statSync(resolved);
+  if (stat.size > MAX_IMAGE_SIZE) {
+    throw new Error(`Image too large (${(stat.size / 1024 / 1024).toFixed(1)}MB, max 10MB)`);
+  }
+
+  const file = Bun.file(resolved);
+  const formData = new FormData();
+  const blob = new Blob([await file.arrayBuffer()], {
+    type: file.type || "application/octet-stream",
+  });
+  formData.append("image", blob, path.basename(resolved));
+
+  const response = await fetch(`http://localhost/sessions/${sessionId}/upload-image`, {
+    unix: socket,
+    method: "POST",
+    body: formData,
+  });
+
+  if (!response.ok) {
+    const errorData = await readErrorJson(response);
+    throw new Error(responseErrorMessage(response, errorData));
+  }
+
+  const result = await readJson<{ path: string }>(response);
+  return result.path;
+}
+
+export async function downloadUrl(url: string): Promise<string> {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download ${url}: HTTP ${response.status}`);
+  }
+
+  const contentType = response.headers.get("content-type") || "";
+  let ext = path.extname(new URL(url).pathname) || ".png";
+  if (contentType.includes("jpeg") || contentType.includes("jpg")) ext = ".jpg";
+  else if (contentType.includes("png")) ext = ".png";
+  else if (contentType.includes("gif")) ext = ".gif";
+  else if (contentType.includes("webp")) ext = ".webp";
+
+  const tmpPath = path.join(os.tmpdir(), `codepiper-dl-${Date.now()}${ext}`);
+  await Bun.write(tmpPath, response);
+  return tmpPath;
+}
+
+export async function sendText(options: SendOptions): Promise<void> {
+  const payload = {
+    text: options.text,
+    newline: options.newline,
+  };
+
+  try {
+    const response = await fetch(`http://localhost/sessions/${options.sessionId}/send`, {
+      unix: options.socket,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(payload),
+    });
+
+    if (!response.ok) {
+      const errorData = await readErrorJson(response);
+      throw new Error(responseErrorMessage(response, errorData));
+    }
+  } catch (error: any) {
+    if (error.code === "ENOENT" || error.message?.includes("ENOENT")) {
+      throw new Error(`Failed to connect to daemon at ${options.socket}. Is the daemon running?`);
+    }
+    throw error;
+  }
+}
+
+export async function runSendCommand(args: string[]): Promise<void> {
+  const options = parseSendOptions(args);
+  let tmpFile: string | undefined;
+
+  try {
+    if (options.image) {
+      let localPath: string;
+      const isUrl = options.image.startsWith("http://") || options.image.startsWith("https://");
+
+      if (isUrl) {
+        localPath = await downloadUrl(options.image);
+        tmpFile = localPath;
+      } else {
+        localPath = path.resolve(options.image);
+        if (!fs.existsSync(localPath)) {
+          throw new Error(`Image file not found: ${localPath}`);
+        }
+      }
+
+      const uploadedPath = await uploadImage(options.sessionId, localPath, options.socket);
+      options.text = options.text ? `${options.text}\n\n${uploadedPath}` : uploadedPath;
+    }
+
+    await sendText(options);
+    console.log(`Sent to session ${options.sessionId}`);
+  } finally {
+    if (tmpFile) {
+      try {
+        fs.unlinkSync(tmpFile);
+      } catch {
+        // ignore cleanup errors
+      }
+    }
+  }
+}

package/packages/cli/src/commands/sessions.ts

@@ -0,0 +1,202 @@
+import type { ProviderId, SessionHandle, SessionStatus } from "@codepiper/core";
+import { readErrorJson, readJson, responseErrorMessage } from "../lib/api";
+import { getRequiredValue } from "../lib/args";
+
+export interface SessionsOptions {
+  socket: string;
+  format: "table" | "json";
+  provider?: ProviderId;
+  status?: SessionStatus;
+}
+
+const VALID_FORMATS = ["table", "json"];
+
+export function parseSessionsOptions(args: string[]): SessionsOptions {
+  let socket = "/tmp/codepiper.sock";
+  let format: "table" | "json" = "table";
+  let provider: ProviderId | undefined;
+  let status: SessionStatus | undefined;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === undefined) {
+      continue;
+    }
+
+    if (arg === "--socket" || arg === "-s") {
+      socket = getRequiredValue(args, i, arg);
+      i++;
+    } else if (arg === "--format" || arg === "-f") {
+      const formatValue = getRequiredValue(args, i, arg);
+      i++;
+      if (!VALID_FORMATS.includes(formatValue)) {
+        throw new Error(
+          `Invalid format: ${formatValue}. Valid options: ${VALID_FORMATS.join(", ")}`
+        );
+      }
+      format = formatValue as "table" | "json";
+    } else if (arg === "--provider" || arg === "-p") {
+      provider = getRequiredValue(args, i, arg) as ProviderId;
+      i++;
+    } else if (arg === "--status") {
+      status = getRequiredValue(args, i, arg) as SessionStatus;
+      i++;
+    }
+  }
+
+  const options: SessionsOptions = {
+    socket,
+    format,
+  };
+  if (provider !== undefined) {
+    options.provider = provider;
+  }
+  if (status !== undefined) {
+    options.status = status;
+  }
+
+  return options;
+}
+
+export async function listSessions(options: SessionsOptions): Promise<SessionHandle[]> {
+  const params = new URLSearchParams();
+  if (options.provider) {
+    params.append("provider", options.provider);
+  }
+  if (options.status) {
+    params.append("status", options.status);
+  }
+
+  const queryString = params.toString();
+  const url = `http://localhost/sessions${queryString ? `?${queryString}` : ""}`;
+
+  try {
+    const response = await fetch(url, {
+      unix: options.socket,
+      method: "GET",
+    });
+
+    if (!response.ok) {
+      const errorData = await readErrorJson(response);
+      throw new Error(responseErrorMessage(response, errorData));
+    }
+
+    const data = await readJson<{ sessions?: any[] }>(response);
+    const sessions = data.sessions || [];
+
+    return sessions.map((s: any) => ({
+      id: s.id,
+      provider: s.provider,
+      cwd: s.cwd,
+      status: s.status,
+      createdAt: new Date(s.createdAt),
+      updatedAt: new Date(s.updatedAt),
+      pid: s.pid,
+      transcriptPath: s.transcriptPath,
+      metadata: s.metadata,
+    }));
+  } catch (error: any) {
+    if (error.code === "ENOENT" || error.message?.includes("ENOENT")) {
+      throw new Error(`Failed to connect to daemon at ${options.socket}. Is the daemon running?`);
+    }
+    throw error;
+  }
+}
+
+// ANSI color codes
+const colors = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  // Status colors
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  blue: "\x1b[34m",
+  cyan: "\x1b[36m",
+  gray: "\x1b[90m",
+};
+
+function getStatusColor(status: SessionStatus): string {
+  switch (status) {
+    case "RUNNING":
+      return colors.green;
+    case "STARTING":
+      return colors.yellow;
+    case "STOPPED":
+      return colors.gray;
+    case "CRASHED":
+      return colors.red;
+    case "NEEDS_PERMISSION":
+      return colors.blue;
+    case "NEEDS_INPUT":
+      return colors.cyan;
+    default:
+      return colors.reset;
+  }
+}
+
+function formatTable(sessions: SessionHandle[]): void {
+  if (sessions.length === 0) {
+    console.log(`${colors.dim}No sessions found.${colors.reset}`);
+    return;
+  }
+
+  // Calculate column widths
+  const idWidth = Math.max(8, ...sessions.map((s) => s.id.slice(0, 8).length));
+  const providerWidth = Math.max(12, ...sessions.map((s) => s.provider.length));
+  const statusWidth = Math.max(8, ...sessions.map((s) => s.status.length));
+
+  // Print header with bold
+  console.log(
+    `${colors.bold}${"ID".padEnd(idWidth)}  ${"PROVIDER".padEnd(providerWidth)}  ${"STATUS".padEnd(statusWidth)}  ${"DIRECTORY".padEnd(35)}  ${"CREATED"}${colors.reset}`
+  );
+  console.log(
+    colors.dim +
+      "─".repeat(idWidth + 2 + providerWidth + 2 + statusWidth + 2 + 35 + 2 + 25) +
+      colors.reset
+  );
+
+  // Print rows with colored status
+  for (const session of sessions) {
+    const shortId = session.id.slice(0, 8);
+    const cwd = session.cwd.length > 35 ? `...${session.cwd.slice(-32)}` : session.cwd;
+    const created = session.createdAt.toLocaleString();
+    const statusColor = getStatusColor(session.status);
+
+    console.log(
+      `${colors.cyan}${shortId.padEnd(idWidth)}${colors.reset}  ${session.provider.padEnd(providerWidth)}  ${statusColor}${session.status.padEnd(statusWidth)}${colors.reset}  ${colors.dim}${cwd.padEnd(35)}${colors.reset}  ${colors.dim}${created}${colors.reset}`
+    );
+  }
+
+  // Summary with counts by status
+  const statusCounts = sessions.reduce(
+    (acc, s) => {
+      acc[s.status] = (acc[s.status] || 0) + 1;
+      return acc;
+    },
+    {} as Record<string, number>
+  );
+
+  const statusSummary = Object.entries(statusCounts)
+    .map(([status, count]) => {
+      const color = getStatusColor(status as SessionStatus);
+      return `${color}${count} ${status.toLowerCase()}${colors.reset}`;
+    })
+    .join(", ");
+
+  console.log(
+    `\n${colors.bold}Total:${colors.reset} ${sessions.length} session(s) (${statusSummary})`
+  );
+}
+
+export async function runSessionsCommand(args: string[]): Promise<void> {
+  const options = parseSessionsOptions(args);
+  const sessions = await listSessions(options);
+
+  if (options.format === "json") {
+    console.log(JSON.stringify(sessions, null, 2));
+  } else {
+    formatTable(sessions);
+  }
+}

package/packages/cli/src/commands/slash.ts

@@ -0,0 +1,92 @@
+import { readErrorJson, responseErrorMessage } from "../lib/api";
+import { getRequiredValue } from "../lib/args";
+
+export interface SlashOptions {
+  sessionId: string;
+  command: string;
+  args?: string[];
+  socket: string;
+}
+
+export function parseSlashOptions(args: string[]): SlashOptions {
+  let sessionId: string | undefined;
+  let command: string | undefined;
+  let socket = "/tmp/codepiper.sock";
+  const commandArgs: string[] = [];
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === undefined) {
+      continue;
+    }
+
+    if (arg === "--socket" || arg === "-s") {
+      socket = getRequiredValue(args, i, arg);
+      i++;
+    } else if (!arg.startsWith("-")) {
+      if (!sessionId) {
+        sessionId = arg;
+      } else if (!command) {
+        command = arg;
+      } else {
+        commandArgs.push(arg);
+      }
+    }
+  }
+
+  if (!sessionId) {
+    throw new Error("session-id is required");
+  }
+
+  if (!command) {
+    throw new Error("command is required");
+  }
+
+  const options: SlashOptions = {
+    sessionId,
+    command,
+    socket,
+  };
+  if (commandArgs.length > 0) {
+    options.args = commandArgs;
+  }
+
+  return options;
+}
+
+export async function sendSlashCommand(options: SlashOptions): Promise<void> {
+  const payload = {
+    command: options.command,
+    args: options.args,
+  };
+
+  try {
+    const response = await fetch(`http://localhost/sessions/${options.sessionId}/slash`, {
+      unix: options.socket,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(payload),
+    });
+
+    if (!response.ok) {
+      const errorData = await readErrorJson(response);
+      throw new Error(responseErrorMessage(response, errorData));
+    }
+  } catch (error: any) {
+    if (error.code === "ENOENT" || error.message?.includes("ENOENT")) {
+      throw new Error(`Failed to connect to daemon at ${options.socket}. Is the daemon running?`);
+    }
+    throw error;
+  }
+}
+
+export async function runSlashCommand(args: string[]): Promise<void> {
+  const options = parseSlashOptions(args);
+
+  await sendSlashCommand(options);
+
+  const argsStr = options.args ? ` ${options.args.join(" ")}` : "";
+  console.log(`Slash command sent to session ${options.sessionId}: /${options.command}${argsStr}`);
+}