@pdpp/cli 0.1.0-beta.2 → 0.1.0-beta.4

package/src/ref/output.js

@@ -0,0 +1,76 @@
+export function resolveFormat(flags, defaultWhenTty = 'json', defaultWhenPipe = 'json') {
+  return flags.format || (process.stdout.isTTY ? defaultWhenTty : defaultWhenPipe);
+}
+
+export function writeData(data, format = 'json', out = process.stdout) {
+  if (format === 'json') {
+    out.write(`${JSON.stringify(data, null, 2)}\n`);
+    return;
+  }
+
+  if (format === 'jsonl') {
+    if (!Array.isArray(data)) {
+      out.write(`${JSON.stringify(data)}\n`);
+      return;
+    }
+    for (const item of data) {
+      out.write(`${JSON.stringify(item)}\n`);
+    }
+    return;
+  }
+
+  if (format === 'table') {
+    writeTable(data, out);
+    return;
+  }
+
+  throw new Error(`Unsupported format: ${format}`);
+}
+
+function writeTable(data, out = process.stdout) {
+  const rows = Array.isArray(data) ? data : [data];
+  if (!rows.length) {
+    out.write('(empty)\n');
+    return;
+  }
+
+  const normalized = rows.map((row) => flattenRow(row));
+  const columns = Array.from(
+    normalized.reduce((acc, row) => {
+      Object.keys(row).forEach((key) => acc.add(key));
+      return acc;
+    }, new Set())
+  );
+
+  const widths = Object.fromEntries(
+    columns.map((column) => [
+      column,
+      Math.max(column.length, ...normalized.map((row) => String(row[column] ?? '').length)),
+    ])
+  );
+
+  const renderRow = (row) =>
+    columns
+      .map((column) => String(row[column] ?? '').padEnd(widths[column]))
+      .join('  ');
+
+  out.write(`${renderRow(Object.fromEntries(columns.map((column) => [column, column])))}\n`);
+  out.write(`${columns.map((column) => '-'.repeat(widths[column])).join('  ')}\n`);
+  for (const row of normalized) {
+    out.write(`${renderRow(row)}\n`);
+  }
+}
+
+function flattenRow(row) {
+  const out = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (Array.isArray(value)) {
+      out[key] = value.join(', ');
+    } else if (value && typeof value === 'object') {
+      out[key] = JSON.stringify(value);
+    } else {
+      out[key] = value ?? '';
+    }
+  }
+  return out;
+}

package/src/ref/session.js

@@ -0,0 +1,107 @@
+import { existsSync, mkdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+import { writePdppSecretFile } from '../cache-layout.js';
+import { PdppCliError } from './errors.js';
+
+const SESSION_DIR_NAME = 'owner-sessions';
+
+export function getOwnerSessionPaths(referenceUrl, opts = {}) {
+  const cacheRoot = opts.cacheRoot || '.pdpp';
+  const dir = join(cacheRoot, SESSION_DIR_NAME);
+  const file = join(dir, `${sessionCacheKey(referenceUrl)}.json`);
+  return { cacheRoot, dir, file };
+}
+
+function sessionCacheKey(referenceUrl) {
+  try {
+    const u = new URL(referenceUrl);
+    // Owner sessions are origin-scoped. Include protocol so an HTTPS login
+    // cannot be silently reused for an HTTP reference URL on the same host.
+    return `${u.protocol}//${u.host}`.replace(/[^a-zA-Z0-9.-]/g, '_');
+  } catch {
+    return referenceUrl.replace(/[^a-zA-Z0-9.-]/g, '_');
+  }
+}
+
+export function writeOwnerSession({ referenceUrl, cookie, cacheRoot } = {}) {
+  if (!referenceUrl) throw new PdppCliError('writeOwnerSession requires referenceUrl');
+  if (!cookie) throw new PdppCliError('writeOwnerSession requires cookie');
+
+  const { file } = getOwnerSessionPaths(referenceUrl, { cacheRoot });
+  const payload = {
+    reference_url: referenceUrl,
+    cookie,
+    saved_at: new Date().toISOString(),
+  };
+  writePdppSecretFile(file, JSON.stringify(payload, null, 2));
+  ensureGitignore(cacheRoot || '.pdpp');
+  return file;
+}
+
+export function readOwnerSession({ referenceUrl, cacheRoot } = {}) {
+  if (!referenceUrl) return null;
+  const { file } = getOwnerSessionPaths(referenceUrl, { cacheRoot });
+  if (!existsSync(file)) return null;
+  try {
+    const data = JSON.parse(readFileSync(file, 'utf8'));
+    if (data && typeof data.cookie === 'string' && data.cookie.length > 0) {
+      return { cookie: data.cookie, savedAt: data.saved_at || null, file };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+export function clearOwnerSession({ referenceUrl, cacheRoot } = {}) {
+  if (!referenceUrl) return false;
+  const { file } = getOwnerSessionPaths(referenceUrl, { cacheRoot });
+  if (!existsSync(file)) return false;
+  try {
+    unlinkSync(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getOwnerSessionFileMode(referenceUrl, opts = {}) {
+  const { file } = getOwnerSessionPaths(referenceUrl, opts);
+  if (!existsSync(file)) return null;
+  return statSync(file).mode & 0o777;
+}
+
+function ensureGitignore(cacheRoot) {
+  const gi = join(cacheRoot, '.gitignore');
+  try {
+    mkdirSync(dirname(gi), { recursive: true, mode: 0o700 });
+    if (!existsSync(gi)) {
+      writeFileSync(gi, '*\n!.gitignore\n', { mode: 0o600 });
+    }
+  } catch {
+    // best-effort; never block CLI on .gitignore creation
+  }
+}
+
+// Parse a Set-Cookie header value (or array of values) and return the value of
+// the named cookie if present, e.g. "pdpp_owner_session=abc; Path=/; HttpOnly".
+export function extractCookieFromSetCookie(setCookie, cookieName) {
+  if (!setCookie) return null;
+  const headers = Array.isArray(setCookie) ? setCookie : [setCookie];
+  for (const raw of headers) {
+    if (typeof raw !== 'string') continue;
+    // Set-Cookie may contain multiple cookies joined by ", " when collapsed.
+    // Split conservatively on the first attribute pair only.
+    for (const piece of raw.split(/,\s*(?=[^;]+=[^;]+)/)) {
+      const [pair] = piece.split(';');
+      if (!pair) continue;
+      const eq = pair.indexOf('=');
+      if (eq === -1) continue;
+      const name = pair.slice(0, eq).trim();
+      const value = pair.slice(eq + 1).trim();
+      if (name === cookieName) return value;
+    }
+  }
+  return null;
+}