v0.9.7: a turn that cannot hang, a session list that reads nothing twice, and PDFs
- consent: on_permission / on_ask_user wait at most two / five minutes, and in
the background (a phone off screen, a window that is gone) the answer is
refused at once with a reason -- a dialog nobody can see blocked the worker
for good, which is what "the app hangs while the agent works" looked like.
- finishTurn() no longer joins the thread it is called from; the event loop
reaps the Turn instead.
- AndroidTools: the hop to the GUI thread pings first and gives up after 3 s
instead of waiting forever on a busy GUI thread.
- the session list stopped reading every transcript: cst_agent_store_info()
counts newlines in 64 KiB blocks (first_user only within the first 256 KiB),
and AgentCore::sessions() reuses a row while (mtime, size) is unchanged.
- session_search gets a budget (max_bytes 32 MB, max_seconds 5 s), skips lines
over 64 KiB, and says when the budget stopped the walk.
- the header shows the phase ("shell: make -j8"), so a long turn no longer
looks like a stuck one.
- md_to_pdf: the front end's own Qt tool (owner app:qt, every platform):
markdown or a workspace .md/.html becomes an A4 PDF with 15 mm margins,
paginated by hand, written into the workspace and delivered as a file card.
No PrintSupport, so the phone gets it too.
- --uitest runs md_to_pdf through the registry with Chinese text and checks the
bytes are a PDF; app/CMakeLists.txt no longer drops src/web_md.c from the
standalone engine build, which the window needs to render markdown.
Version 0.9.7.
This commit is contained in:
WHC
@@ -0,0 +1,315 @@
|
||||
/* The window's own tools, in Qt rather than in the engine: a document the
|
||||
* person asked for, laid out as a PDF.
|
||||
*
|
||||
* Why here and not in the C engine: laying text out on pages is exactly what
|
||||
* Qt does (QTextDocument + QPdfWriter, both in QtGui, which the app already
|
||||
* links), while the engine has no layout code at all -- and md_to_html, its
|
||||
* sibling, lives in the engine because rendering markdown is a shared
|
||||
* capability. This one is a front-end capability: it is registered under
|
||||
* owner "app:qt" and is available on every platform the app runs on.
|
||||
*
|
||||
* The path of a document is the one md_to_html walks: markdown (or a
|
||||
* workspace .md/.html file) -> cst_web_md_document() -> a file inside the
|
||||
* workspace -> cst_attach_import_artifact(), which is what turns it into a
|
||||
* file card the person can open or share. The bytes never reach the model.
|
||||
*
|
||||
* Pagination is ours on purpose: QPrinter/PrintSupport is a desktop-only
|
||||
* module (a phone has no print subsystem), and a round of
|
||||
* pageSize + translate + drawContents per page is all a paginated PDF needs.
|
||||
* The tool runs on the turn's worker thread, so a long document does not
|
||||
* freeze the window. */
|
||||
|
||||
#include <QByteArray>
|
||||
#include <QDir>
|
||||
#include <QFile>
|
||||
#include <QFileInfo>
|
||||
#include <QMarginsF>
|
||||
#include <QPageLayout>
|
||||
#include <QPageSize>
|
||||
#include <QPainter>
|
||||
#include <QPdfWriter>
|
||||
#include <QRectF>
|
||||
#include <QString>
|
||||
#include <QTextDocument>
|
||||
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
|
||||
#include "core/AgentCore.h"
|
||||
#include "core/ToolProvider.h"
|
||||
#include "cst_agent.h"
|
||||
#include "cst_attach.h"
|
||||
#include "cst_tools.h"
|
||||
#include "cst_web_md.h"
|
||||
|
||||
namespace app {
|
||||
namespace {
|
||||
|
||||
/* md_to_html caps its input the same way: a document nobody could read is
|
||||
* not worth laying out. */
|
||||
constexpr int kMaxInputBytes = 8 * 1024 * 1024;
|
||||
/* 150 dpi: crisp enough for text, and a good deal lighter on a phone than the
|
||||
* default 300 (a 40-page document is laid out and written in a moment). */
|
||||
constexpr int kPdfDpi = 150;
|
||||
|
||||
const char *argOf(const ctl_tool_call_t *call, const char *key) {
|
||||
for (int i = 0; i < call->nargs; i++)
|
||||
if (strcmp(call->args[i].key, key) == 0)
|
||||
return call->args[i].value;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
int setOut(cst_tool_result_t *r, const QString &text, int rc) {
|
||||
const QByteArray b = text.toUtf8();
|
||||
r->out = strdup(b.constData());
|
||||
r->out_len = r->out ? strlen(r->out) : 0;
|
||||
r->exit_code = rc;
|
||||
return rc;
|
||||
}
|
||||
|
||||
/* "docs/notes.md" -> "notes". */
|
||||
QString stemOf(const QString &path) {
|
||||
QString base = path;
|
||||
const int slash = qMax(base.lastIndexOf(QLatin1Char('/')),
|
||||
base.lastIndexOf(QLatin1Char('\\')));
|
||||
if (slash >= 0)
|
||||
base = base.mid(slash + 1);
|
||||
const int dot = base.lastIndexOf(QLatin1Char('.'));
|
||||
if (dot > 0)
|
||||
base = base.left(dot);
|
||||
return base.isEmpty() ? QStringLiteral("document") : base;
|
||||
}
|
||||
|
||||
/* What the file is called: `out` when given (a directory takes the source's
|
||||
* name inside it), otherwise the source's stem, or the title. */
|
||||
QString outPathOf(const ctl_tool_call_t *c, const QString &stem) {
|
||||
const char *out = argOf(c, "out");
|
||||
QString name = out && out[0] ? QString::fromUtf8(out) : QString();
|
||||
if (name.isEmpty())
|
||||
return stem + QStringLiteral(".pdf");
|
||||
if (name.endsWith(QLatin1Char('/')) || name.endsWith(QLatin1Char('\\')))
|
||||
return name + stem + QStringLiteral(".pdf");
|
||||
if (!QFileInfo(name).fileName().contains(QLatin1Char('.')))
|
||||
name += QStringLiteral(".pdf");
|
||||
return name;
|
||||
}
|
||||
|
||||
/* The HTML that goes into the page: an .html file is already a document, a
|
||||
* .md file (or the `markdown` argument) goes through the engine's renderer,
|
||||
* which is the same one the WebUI and md_to_html use. */
|
||||
bool sourceHtml(const cst_tool_ctx_t *ctx, const ctl_tool_call_t *c,
|
||||
QString *html, QString *out_name, QString *err) {
|
||||
const char *md = argOf(c, "markdown");
|
||||
const char *file = argOf(c, "file");
|
||||
const char *given = argOf(c, "title");
|
||||
QString title = given && given[0] ? QString::fromUtf8(given) : QString();
|
||||
QByteArray text;
|
||||
QString stem;
|
||||
if (file && file[0]) {
|
||||
char rel[4096] = "";
|
||||
if (cst_sandbox_resolve(ctx->workspace_root, file, rel, sizeof(rel)) != 0) {
|
||||
*err = QStringLiteral("error: path outside the workspace or missing "
|
||||
"parent: %1")
|
||||
.arg(QString::fromUtf8(file));
|
||||
return false;
|
||||
}
|
||||
QFile in(QString::fromUtf8(rel));
|
||||
if (!in.open(QIODevice::ReadOnly)) {
|
||||
*err = QStringLiteral("error: cannot read %1")
|
||||
.arg(QString::fromUtf8(file));
|
||||
return false;
|
||||
}
|
||||
if (in.size() > kMaxInputBytes) {
|
||||
*err = QStringLiteral("error: %1 is larger than %2 MB")
|
||||
.arg(QString::fromUtf8(file))
|
||||
.arg(kMaxInputBytes >> 20);
|
||||
return false;
|
||||
}
|
||||
text = in.readAll();
|
||||
stem = stemOf(QString::fromUtf8(file));
|
||||
const QString lower = QString::fromUtf8(file).toLower();
|
||||
if (lower.endsWith(QLatin1String(".html")) ||
|
||||
lower.endsWith(QLatin1String(".htm"))) {
|
||||
/* already a document: what md_to_html wrote, or anything else */
|
||||
*html = QString::fromUtf8(text);
|
||||
if (title.isEmpty())
|
||||
title = stem;
|
||||
*out_name = outPathOf(c, stem);
|
||||
return true;
|
||||
}
|
||||
} else if (md && md[0]) {
|
||||
text = QByteArray(md);
|
||||
if (stem.isEmpty())
|
||||
stem = title.isEmpty() ? QStringLiteral("document") : stemOf(title);
|
||||
} else {
|
||||
*err = QStringLiteral("error: give markdown, or a workspace .md or .html "
|
||||
"file to render");
|
||||
return false;
|
||||
}
|
||||
if (title.isEmpty())
|
||||
title = stem;
|
||||
char *doc =
|
||||
cst_web_md_document(text.constData(), static_cast<size_t>(text.size()),
|
||||
title.toUtf8().constData());
|
||||
if (!doc) {
|
||||
*err = QStringLiteral("error: cannot render the markdown");
|
||||
return false;
|
||||
}
|
||||
*html = QString::fromUtf8(doc);
|
||||
free(doc);
|
||||
*out_name = outPathOf(c, stem);
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Write `html` into `path` as an A4 PDF with 15 mm margins: one page rect,
|
||||
* translated down per page, and the document is asked for exactly that much
|
||||
* text at a time -- which is what makes Qt lay out pages instead of one long
|
||||
* strip. */
|
||||
bool writePdf(const QString &html, const QString &path, const QString &title,
|
||||
QString *err) {
|
||||
QTextDocument doc;
|
||||
doc.setHtml(html);
|
||||
if (!title.isEmpty())
|
||||
doc.setMetaInformation(QTextDocument::DocumentTitle, title);
|
||||
|
||||
QPdfWriter writer(path);
|
||||
writer.setPageSize(QPageSize(QPageSize::A4));
|
||||
writer.setPageMargins(QMarginsF(15, 15, 15, 15), QPageLayout::Millimeter);
|
||||
writer.setResolution(kPdfDpi);
|
||||
if (!title.isEmpty())
|
||||
writer.setTitle(title);
|
||||
|
||||
QPainter painter(&writer);
|
||||
if (!painter.isActive()) {
|
||||
*err = QStringLiteral("error: cannot draw into %1").arg(path);
|
||||
return false;
|
||||
}
|
||||
const QRectF page = writer.pageLayout().paintRectPixels(writer.resolution());
|
||||
doc.setPageSize(page.size());
|
||||
const int pages = qMax(1, doc.pageCount());
|
||||
for (int i = 0; i < pages; i++) {
|
||||
if (i)
|
||||
writer.newPage();
|
||||
painter.save();
|
||||
painter.translate(page.topLeft());
|
||||
painter.translate(0, -i * page.height());
|
||||
doc.drawContents(&painter,
|
||||
QRectF(0, 0, page.width(), page.height())
|
||||
.translated(0, i * page.height()));
|
||||
painter.restore();
|
||||
}
|
||||
painter.end();
|
||||
/* The painter says nothing about the file: the only proof the PDF landed is
|
||||
* that there is one with bytes in it. */
|
||||
if (QFileInfo(path).size() <= 0) {
|
||||
*err = QStringLiteral("error: nothing was written to %1").arg(path);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
int mdToPdfPreview(const cst_tool_ctx_t *ctx, const ctl_tool_call_t *c,
|
||||
char **out) {
|
||||
(void)ctx;
|
||||
const char *md = argOf(c, "markdown");
|
||||
const char *file = argOf(c, "file");
|
||||
if ((!md || !md[0]) && (!file || !file[0])) {
|
||||
*out = strdup("error: give markdown, or a .md or .html file to render");
|
||||
return -1;
|
||||
}
|
||||
const QString stem =
|
||||
file && file[0] ? stemOf(QString::fromUtf8(file)) : QStringLiteral("document");
|
||||
const QString name = outPathOf(c, stem);
|
||||
QByteArray line;
|
||||
if (file && file[0])
|
||||
line = QStringLiteral("lay out %1 → %2 as a PDF\n")
|
||||
.arg(QString::fromUtf8(file), name)
|
||||
.toUtf8();
|
||||
else
|
||||
line = QStringLiteral("lay out %1 bytes of markdown → %2 as a PDF\n")
|
||||
.arg(md ? qstrlen(md) : 0)
|
||||
.arg(name)
|
||||
.toUtf8();
|
||||
*out = strdup(line.constData());
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mdToPdfRun(const cst_tool_ctx_t *ctx, const ctl_tool_call_t *c,
|
||||
cst_tool_result_t *r, void *ud) {
|
||||
(void)ud;
|
||||
QString html, out_name, err;
|
||||
if (!sourceHtml(ctx, c, &html, &out_name, &err))
|
||||
return setOut(r, err, 1);
|
||||
|
||||
char full[4096] = "";
|
||||
if (cst_sandbox_resolve(ctx->workspace_root, out_name.toUtf8().constData(),
|
||||
full, sizeof(full)) != 0)
|
||||
return setOut(r, QStringLiteral("error: path outside the workspace: %1")
|
||||
.arg(out_name),
|
||||
1);
|
||||
const QString target = QString::fromUtf8(full);
|
||||
/* A directory in the way of the name is what the engine's write tools call
|
||||
* "missing parent": make it, the same way md_to_html does. */
|
||||
QDir().mkpath(QFileInfo(target).absolutePath());
|
||||
|
||||
const char *given = argOf(c, "title");
|
||||
const QString title = given && given[0] ? QString::fromUtf8(given) : QString();
|
||||
if (!writePdf(html, target, title, &err))
|
||||
return setOut(r, err, 1);
|
||||
|
||||
const qint64 bytes = QFileInfo(target).size();
|
||||
const char *session = ctx->agent ? cst_agent_session_path(ctx->agent) : nullptr;
|
||||
cst_attachment_t *a = nullptr;
|
||||
char aerr[256] = "";
|
||||
if (session && session[0])
|
||||
a = cst_attach_import_artifact(session, full, nullptr, aerr, sizeof(aerr));
|
||||
|
||||
QString text = QStringLiteral("wrote %1 (%2 KB, A4, 15 mm margins)\n")
|
||||
.arg(out_name)
|
||||
.arg(bytes / 1024);
|
||||
if (a)
|
||||
text += QStringLiteral("(the user sees it as a file card they can open or "
|
||||
"share; you will not be shown its bytes again)\n");
|
||||
else if (aerr[0])
|
||||
text += QStringLiteral("(the file is in the workspace; handing it over "
|
||||
"failed: %1)\n")
|
||||
.arg(QString::fromUtf8(aerr));
|
||||
const int rc = setOut(r, text, 0);
|
||||
if (a) {
|
||||
r->attach = a;
|
||||
r->nattach = 1;
|
||||
}
|
||||
return rc;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
int registerQtTools(AgentCore *core) {
|
||||
if (!core)
|
||||
return 0;
|
||||
static const cst_tool_param_t params[CST_TOOL_MAX_PARAMS] = {
|
||||
{"markdown", "string", 0, "markdown text to render"},
|
||||
{"file", "string", 0,
|
||||
"workspace .md file to render, or an .html one to lay out as it is"},
|
||||
{"out", "string", 0,
|
||||
"output path in the workspace (default: the source's name + .pdf)"},
|
||||
{"title", "string", 0, "document title (default: the file name)"},
|
||||
{nullptr, nullptr, 0, nullptr},
|
||||
{nullptr, nullptr, 0, nullptr}};
|
||||
static cst_tool_def_t def;
|
||||
memset(&def, 0, sizeof(def));
|
||||
setMeta(&def, "md_to_pdf",
|
||||
"Write a document as a PDF: markdown (or a workspace .md/.html "
|
||||
"file) in, a laid-out A4 PDF out, saved in the workspace and "
|
||||
"handed to the person as a card they can open, print or share. "
|
||||
"Use it when the answer should be something to keep or send.",
|
||||
CST_TP_WRITE, "pdf", nullptr, nullptr);
|
||||
memcpy(def.params, params, sizeof(params));
|
||||
def.run_ex = mdToPdfRun;
|
||||
def.preview = mdToPdfPreview;
|
||||
def.owner = "app:qt";
|
||||
return core->registerTool(&def) ? 1 : 0;
|
||||
}
|
||||
|
||||
} // namespace app
|
||||
Reference in New Issue
Block a user